mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-04 23:11:41 +08:00
update
This commit is contained in:
@@ -0,0 +1,48 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始长度为 <code>n</code> 的数组 <code>nums</code> 。</p>
|
||||
|
||||
<p>每一秒，你可以对数组执行以下操作：</p>
|
||||
|
||||
<ul>
|
||||
<li>对于范围在 <code>[0, n - 1]</code> 内的每一个下标 <code>i</code> ，将 <code>nums[i]</code> 替换成 <code>nums[i]</code> ，<code>nums[(i - 1 + n) % n]</code> 或者 <code>nums[(i + 1) % n]</code> 三者之一。</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>注意</strong>，所有元素会被同时替换。</p>
|
||||
|
||||
<p>请你返回将数组 <code>nums</code> 中所有元素变成相等元素所需要的 <strong>最少</strong> 秒数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1,2,1,2]
|
||||
<b>输出：</b>1
|
||||
<b>解释：</b>我们可以在 1 秒内将数组变成相等元素：
|
||||
- 第 1 秒，将每个位置的元素分别变为 [nums[3],nums[1],nums[3],nums[3]] 。变化后，nums = [2,2,2,2] 。
|
||||
1 秒是将数组变成相等元素所需要的最少秒数。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2,1,3,3,2]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>我们可以在 2 秒内将数组变成相等元素：
|
||||
- 第 1 秒，将每个位置的元素分别变为 [nums[0],nums[2],nums[2],nums[2],nums[3]] 。变化后，nums = [2,3,3,3,3] 。
|
||||
- 第 2 秒，将每个位置的元素分别变为 [nums[1],nums[1],nums[2],nums[3],nums[4]] 。变化后，nums = [3,3,3,3,3] 。
|
||||
2 秒是将数组变成相等元素所需要的最少秒数。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [5,5,5,5]
|
||||
<b>输出：</b>0
|
||||
<b>解释：</b>不需要执行任何操作，因为一开始数组中的元素已经全部相等。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>给你两个长度相等下标从 <strong>0</strong> 开始的整数数组 <code>nums1</code> 和 <code>nums2</code> 。每一秒，对于所有下标 <code>0 <= i < nums1.length</code> ，<code>nums1[i]</code> 的值都增加 <code>nums2[i]</code> 。操作 <strong>完成后</strong> ，你可以进行如下操作：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择任一满足 <code>0 <= i < nums1.length</code> 的下标 <code>i</code> ，并使 <code>nums1[i] = 0</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>同时给你一个整数 <code>x</code> 。</p>
|
||||
|
||||
<p>请你返回使 <code>nums1</code> 中所有元素之和 <strong>小于等于</strong> <code>x</code> 所需要的 <strong>最少</strong> 时间，如果无法实现，那么返回 <code>-1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums1 = [1,2,3], nums2 = [1,2,3], x = 4
|
||||
<b>输出：</b>3
|
||||
<b>解释：</b>
|
||||
第 1 秒，我们对 i = 0 进行操作，得到 nums1 = [0,2+2,3+3] = [0,4,6] 。
|
||||
第 2 秒，我们对 i = 1 进行操作，得到 nums1 = [0+1,0,6+3] = [1,0,9] 。
|
||||
第 3 秒，我们对 i = 2 进行操作，得到 nums1 = [1+1,0+2,0] = [2,2,0] 。
|
||||
现在 nums1 的和为 4 。不存在更少次数的操作，所以我们返回 3 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums1 = [1,2,3], nums2 = [3,3,3], x = 4
|
||||
<b>输出：</b>-1
|
||||
<b>解释：</b>不管如何操作，nums1 的和总是会超过 x 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length <= 10<sup>3</sup></code></li>
|
||||
<li><code>1 <= nums1[i] <= 10<sup>3</sup></code></li>
|
||||
<li><code>0 <= nums2[i] <= 10<sup>3</sup></code></li>
|
||||
<li><code>nums1.length == nums2.length</code></li>
|
||||
<li><code>0 <= x <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,57 @@
|
||||
<p>给你一个长度为 <code>n</code> 的数组 <code>nums</code> 和一个整数 <code>m</code> 。请你判断能否执行一系列操作，将数组拆分成 <code>n</code> 个 <strong>非空 </strong>数组。</p>
|
||||
|
||||
<p>在每一步操作中，你可以选择一个 <strong>长度至少为 2</strong> 的现有数组（之前步骤的结果） 并将其拆分成 <strong>2</strong> 个子数组，而得到的 <strong>每个</strong> 子数组，<strong>至少</strong> 需要满足以下条件之一：</p>
|
||||
|
||||
<ul>
|
||||
<li>子数组的长度为 1 ，或者</li>
|
||||
<li>子数组元素之和 <strong>大于或等于</strong> <code>m</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>如果你可以将给定数组拆分成 <code>n</code> 个满足要求的数组，返回 <code>true</code><em> </em>；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p><strong>注意：</strong>子数组是数组中的一个连续非空元素序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2, 2, 1], m = 4
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>
|
||||
第 1 步，将数组 nums 拆分成 [2, 2] 和 [1] 。
|
||||
第 2 步，将数组 [2, 2] 拆分成 [2] 和 [2] 。
|
||||
因此，答案为 true 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2, 1, 3], m = 5
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：
|
||||
</strong>存在两种不同的拆分方法：
|
||||
第 1 种，将数组 nums 拆分成 [2, 1] 和 [3] 。
|
||||
第 2 种，将数组 nums 拆分成 [2] 和 [1, 3] 。
|
||||
然而，这两种方法都不满足题意。因此，答案为 false 。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2, 3, 3, 2, 3], m = 6
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>
|
||||
第 1 步，将数组 nums 拆分成 [2, 3, 3, 2] 和 [3] 。
|
||||
第 2 步，将数组 [2, 3, 3, 2] 拆分成 [2, 3, 3] 和 [2] 。
|
||||
第 3 步，将数组 [2, 3, 3] 拆分成 [2] 和 [3, 3] 。
|
||||
第 4 步，将数组 [3, 3] 拆分成 [3] 和 [3] 。
|
||||
因此，答案为 true 。 </pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 100</code></li>
|
||||
<li><code>1 <= m <= 200</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
给你三个字符串 <code>a</code> ，<code>b</code> 和 <code>c</code> ， 你的任务是找到长度 <strong>最短</strong> 的字符串，且这三个字符串都是它的 <strong>子字符串</strong> 。
|
||||
<p>如果有多个这样的字符串，请你返回 <strong>字典序最小</strong> 的一个。</p>
|
||||
|
||||
<p>请你返回满足题目要求的字符串。</p>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>两个长度相同的字符串 <code>a</code> 和 <code>b</code> ，如果在第一个不相同的字符处，<code>a</code> 的字母在字母表中比 <code>b</code> 的字母 <strong>靠前</strong> ，那么字符串 <code>a</code> 比字符串 <code>b</code> <strong>字典序小</strong> 。</li>
|
||||
<li><strong>子字符串</strong> 是一个字符串中一段连续的字符序列。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><code><span style=""><b>输入：</b></span>a</code> = "abc", <code>b</code> = "bca", <code>c</code> = "aaa"
|
||||
<b>输出：</b>"aaabca"
|
||||
<b>解释：</b>字符串 "aaabca" 包含所有三个字符串：a = ans[2...4] ，b = ans[3..5] ，c = ans[0..2] 。结果字符串的长度至少为 6 ，且"aaabca" 是字典序最小的一个。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><code><span style=""><b>输入：</b></span>a</code> = "ab", <code>b</code> = "ba", <code>c</code> = "aba"
|
||||
<b>输出：</b>"aba"
|
||||
<strong>解释：</strong>字符串 "aba" 包含所有三个字符串：a = ans[0..1] ，b = ans[1..2] ，c = ans[0..2] 。由于 c 的长度为 3 ，结果字符串的长度至少为 3 。"aba" 是字典序最小的一个。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= a.length, b.length, c.length <= 100</code></li>
|
||||
<li><code>a</code> ，<code>b</code> ，<code>c</code> 只包含小写英文字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>一开始，你的银行账户里有 <code>100</code> 块钱。</p>
|
||||
|
||||
<p>给你一个整数<code>purchaseAmount</code> ，它表示你在一次购买中愿意支出的金额。</p>
|
||||
|
||||
<p>在一个商店里，你进行一次购买，实际支出的金额会向 <strong>最近</strong> 的 <code>10</code> 的 <strong>倍数</strong> 取整。换句话说，你实际会支付一个 <strong>非负</strong> 金额 <code>roundedAmount</code> ，满足 <code>roundedAmount</code> 是 <code>10</code> 的倍数且 <code>abs(roundedAmount - purchaseAmount)</code> 的值 <strong>最小</strong> 。</p>
|
||||
|
||||
<p>如果存在多于一个最接近的 <code>10</code> 的倍数，<strong>较大的倍数</strong> 是你的实际支出金额。</p>
|
||||
|
||||
<p>请你返回一个整数，表示你在愿意支出金额为<em> </em><code>purchaseAmount</code><em> </em>块钱的前提下，购买之后剩下的余额。</p>
|
||||
|
||||
<p><strong>注意：</strong> <code>0</code> 也是 <code>10</code> 的倍数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>purchaseAmount = 9
|
||||
<b>输出：</b>90
|
||||
<b>解释：</b>这个例子中，最接近 9 的 10 的倍数是 10 。所以你的账户余额为 100 - 10 = 90 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>purchaseAmount = 15
|
||||
<b>输出：</b>80
|
||||
<b>解释：</b>这个例子中，有 2 个最接近 15 的 10 的倍数：10 和 20，较大的数 20 是你的实际开销。
|
||||
所以你的账户余额为 100 - 20 = 80 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= purchaseAmount <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、由正整数组成的数组 <code>nums</code> 。</p>
|
||||
|
||||
<p>你可以在数组上执行下述操作 <strong>任意</strong> 次：</p>
|
||||
|
||||
<ul>
|
||||
<li>选中一个同时满足 <code>0 <= i < nums.length - 1</code> 和 <code>nums[i] <= nums[i + 1]</code> 的整数 <code>i</code> 。将元素 <code>nums[i + 1]</code> 替换为 <code>nums[i] + nums[i + 1]</code> ，并从数组中删除元素 <code>nums[i]</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回你可以从最终数组中获得的 <strong>最大</strong> 元素的值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [2,3,7,9,3]
|
||||
<strong>输出：</strong>21
|
||||
<strong>解释：</strong>我们可以在数组上执行下述操作：
|
||||
- 选中 i = 0 ，得到数组 nums = [<strong><em>5</em></strong>,7,9,3] 。
|
||||
- 选中 i = 1 ，得到数组 nums = [5,<em><strong>16</strong></em>,3] 。
|
||||
- 选中 i = 0 ，得到数组 nums = [<em><strong>21</strong></em>,3] 。
|
||||
最终数组中的最大元素是 21 。可以证明我们无法获得更大的元素。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [5,3,3]
|
||||
<strong>输出：</strong>11
|
||||
<strong>解释：</strong>我们可以在数组上执行下述操作：
|
||||
- 选中 i = 1 ，得到数组 nums = [5,<em><strong>6</strong></em>] 。
|
||||
- 选中 i = 0 ，得到数组 nums = [<em><strong>11</strong></em>] 。
|
||||
最终数组中只有一个元素，即 11 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>给你一个链表的头 <code>head</code> ，每个结点包含一个整数值。</p>
|
||||
|
||||
<p>在相邻结点之间，请你插入一个新的结点，结点值为这两个相邻结点值的 <strong>最大公约数</strong> 。</p>
|
||||
|
||||
<p>请你返回插入之后的链表。</p>
|
||||
|
||||
<p>两个数的 <strong>最大公约数</strong> 是可以被两个数字整除的最大正整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/07/18/ex1_copy.png" style="width: 641px; height: 181px;"></p>
|
||||
|
||||
<pre><b>输入：</b>head = [18,6,10,3]
|
||||
<b>输出：</b>[18,6,6,2,10,1,3]
|
||||
<b>解释：</b>第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。
|
||||
- 18 和 6 的最大公约数为 6 ，插入第一和第二个结点之间。
|
||||
- 6 和 10 的最大公约数为 2 ，插入第二和第三个结点之间。
|
||||
- 10 和 3 的最大公约数为 1 ，插入第三和第四个结点之间。
|
||||
所有相邻结点之间都插入完毕，返回链表。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/07/18/ex2_copy1.png" style="width: 51px; height: 191px;"></p>
|
||||
|
||||
<pre><b>输入：</b>head = [7]
|
||||
<strong>输出：</strong>[7]
|
||||
<b>解释：</b>第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。
|
||||
没有相邻结点，所以返回初始链表。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中结点数目在 <code>[1, 5000]</code> 之间。</li>
|
||||
<li><code>1 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,61 @@
|
||||
<p>给你一个长度为 <code>n</code> 的二维整数数组 <code>items</code> 和一个整数 <code>k</code> 。</p>
|
||||
|
||||
<p><code>items[i] = [profit<sub>i</sub>, category<sub>i</sub>]</code>，其中 <code>profit<sub>i</sub></code> 和 <code>category<sub>i</sub></code> 分别表示第 <code>i</code> 个项目的利润和类别。</p>
|
||||
|
||||
<p>现定义 <code>items</code> 的 <strong>子序列</strong> 的 <strong>优雅度</strong> 可以用 <code>total_profit + distinct_categories<sup>2</sup></code> 计算，其中 <code>total_profit</code> 是子序列中所有项目的利润总和，<code>distinct_categories</code> 是所选子序列所含的所有类别中不同类别的数量。</p>
|
||||
|
||||
<p>你的任务是从 <code>items</code> 所有长度为 <code>k</code> 的子序列中，找出 <strong>最大优雅度</strong> 。</p>
|
||||
|
||||
<p>用整数形式表示并返回 <code>items</code> 中所有长度恰好为 <code>k</code> 的子序列的最大优雅度。</p>
|
||||
|
||||
<p><strong>注意：</strong>数组的子序列是经由原数组删除一些元素（可能不删除）而产生的新数组，且删除不改变其余元素相对顺序。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>items = [[3,2],[5,1],[10,1]], k = 2
|
||||
<strong>输出：</strong>17
|
||||
<strong>解释：
|
||||
</strong>在这个例子中，我们需要选出长度为 2 的子序列。
|
||||
其中一种方案是 items[0] = [3,2] 和 items[2] = [10,1] 。
|
||||
子序列的总利润为 3 + 10 = 13 ，子序列包含 2 种不同类别 [2,1] 。
|
||||
因此，优雅度为 13 + 2<sup>2</sup> = 17 ，可以证明 17 是可以获得的最大优雅度。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>items = [[3,1],[3,1],[2,2],[5,3]], k = 3
|
||||
<strong>输出：</strong>19
|
||||
<strong>解释：</strong>
|
||||
在这个例子中，我们需要选出长度为 3 的子序列。
|
||||
其中一种方案是 items[0] = [3,1] ，items[2] = [2,2] 和 items[3] = [5,3] 。
|
||||
子序列的总利润为 3 + 2 + 5 = 10 ，子序列包含 3 种不同类别 [1, 2, 3] 。
|
||||
因此，优雅度为 10 + 3<sup>2</sup> = 19 ，可以证明 19 是可以获得的最大优雅度。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>items = [[1,1],[2,1],[3,1]], k = 3
|
||||
<strong>输出：</strong>7
|
||||
<strong>解释：
|
||||
</strong>在这个例子中，我们需要选出长度为 3 的子序列。
|
||||
我们需要选中所有项目。
|
||||
子序列的总利润为 1 + 2 + 3 = 6，子序列包含 1 种不同类别 [1] 。
|
||||
因此，最大优雅度为 6 + 1<sup>2</sup> = 7 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= items.length == n <= 10<sup>5</sup></code></li>
|
||||
<li><code>items[i].length == 2</code></li>
|
||||
<li><code>items[i][0] == profit<sub>i</sub></code></li>
|
||||
<li><code>items[i][1] == category<sub>i</sub></code></li>
|
||||
<li><code>1 <= profit<sub>i</sub> <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= category<sub>i</sub> <= n </code></li>
|
||||
<li><code>1 <= k <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>给你两个 <strong>正</strong> 整数 <code>n</code> 和 <code>x</code> 。</p>
|
||||
|
||||
<p>请你返回将<em> </em><code>n</code> 表示成一些 <strong>互不相同</strong> 正整数的<em> </em><code>x</code> 次幂之和的方案数。换句话说，你需要返回互不相同整数 <code>[n<sub>1</sub>, n<sub>2</sub>, ..., n<sub>k</sub>]</code> 的集合数目，满足 <code>n = n<sub>1</sub><sup>x</sup> + n<sub>2</sub><sup>x</sup> + ... + n<sub>k</sub><sup>x</sup></code> 。</p>
|
||||
|
||||
<p>由于答案可能非常大，请你将它对 <code>10<sup>9</sup> + 7</code> 取余后返回。</p>
|
||||
|
||||
<p>比方说，<code>n = 160</code> 且 <code>x = 3</code> ，一个表示 <code>n</code> 的方法是 <code>n = 2<sup>3</sup> + 3<sup>3</sup> + 5<sup>3</sup></code><sup> </sup>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 10, x = 2
|
||||
<b>输出：</b>1
|
||||
<b>解释：</b>我们可以将 n 表示为：n = 3<sup>2</sup> + 1<sup>2</sup> = 10 。
|
||||
这是唯一将 10 表达成不同整数 2 次方之和的方案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 4, x = 1
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>我们可以将 n 按以下方案表示：
|
||||
- n = 4<sup>1</sup> = 4 。
|
||||
- n = 3<sup>1</sup> + 1<sup>1</sup> = 4 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 300</code></li>
|
||||
<li><code>1 <= x <= 5</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串 <code>s</code> ，将 <code>s</code> 中的元素重新 <b>排列</b> 得到新的字符串 <code>t</code> ，它满足：</p>
|
||||
|
||||
<ul>
|
||||
<li>所有辅音字母都在原来的位置上。更正式的，如果满足 <code>0 <= i < s.length</code> 的下标 <code>i</code> 处的 <code>s[i]</code> 是个辅音字母，那么 <code>t[i] = s[i]</code> 。</li>
|
||||
<li>元音字母都必须以他们的 <strong>ASCII</strong> 值按 <strong>非递减</strong> 顺序排列。更正式的，对于满足 <code>0 <= i < j < s.length</code> 的下标 <code>i</code> 和 <code>j</code> ，如果 <code>s[i]</code> 和 <code>s[j]</code> 都是元音字母，那么 <code>t[i]</code> 的 ASCII 值不能大于 <code>t[j]</code> 的 ASCII 值。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回结果字母串。</p>
|
||||
|
||||
<p>元音字母为 <code>'a'</code> ，<code>'e'</code> ，<code>'i'</code> ，<code>'o'</code> 和 <code>'u'</code> ，它们可能是小写字母也可能是大写字母，辅音字母是除了这 5 个字母以外的所有字母。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "lEetcOde"
|
||||
<b>输出：</b>"lEOtcede"
|
||||
<b>解释：</b>'E' ，'O' 和 'e' 是 s 中的元音字母，'l' ，'t' ，'c' 和 'd' 是所有的辅音。将元音字母按照 ASCII 值排序，辅音字母留在原地。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "lYmpH"
|
||||
<b>输出：</b>"lYmpH"
|
||||
<b>解释：</b>s 中没有元音字母（s 中都为辅音字母），所以我们返回 "lYmpH" 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> 只包含英语字母表中的 <strong>大写 </strong>和 <strong>小写 </strong>字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,59 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、大小为 <code>n x n</code> 的二维矩阵 <code>grid</code> ，其中 <code>(r, c)</code> 表示：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果 <code>grid[r][c] = 1</code> ，则表示一个存在小偷的单元格</li>
|
||||
<li>如果 <code>grid[r][c] = 0</code> ，则表示一个空单元格</li>
|
||||
</ul>
|
||||
|
||||
<p>你最开始位于单元格 <code>(0, 0)</code> 。在一步移动中，你可以移动到矩阵中的任一相邻单元格，包括存在小偷的单元格。</p>
|
||||
|
||||
<p>矩阵中路径的 <strong>安全系数</strong> 定义为：从路径中任一单元格到矩阵中任一小偷所在单元格的 <strong>最小</strong> 曼哈顿距离。</p>
|
||||
|
||||
<p>返回所有通向单元格<em> </em><code>(n - 1, n - 1)</code> 的路径中的 <strong>最大安全系数</strong> 。</p>
|
||||
|
||||
<p>单元格 <code>(r, c)</code> 的某个 <strong>相邻</strong> 单元格，是指在矩阵中存在的 <code>(r, c + 1)</code>、<code>(r, c - 1)</code>、<code>(r + 1, c)</code> 和 <code>(r - 1, c)</code> 之一。</p>
|
||||
|
||||
<p>两个单元格 <code>(a, b)</code> 和 <code>(x, y)</code> 之间的 <strong>曼哈顿距离</strong> 等于 <code>| a - x | + | b - y |</code> ，其中 <code>|val|</code> 表示 <code>val</code> 的绝对值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/07/02/example1.png" style="width: 362px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[1,0,0],[0,0,0],[0,0,1]]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>从 (0, 0) 到 (n - 1, n - 1) 的每条路径都经过存在小偷的单元格 (0, 0) 和 (n - 1, n - 1) 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/07/02/example2.png" style="width: 362px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[0,0,1],[0,0,0],[0,0,0]]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>
|
||||
上图所示路径的安全系数为 2：
|
||||
- 该路径上距离小偷所在单元格（0，2）最近的单元格是（0，0）。它们之间的曼哈顿距离为 | 0 - 0 | + | 0 - 2 | = 2 。
|
||||
可以证明，不存在安全系数更高的其他路径。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/07/02/example3.png" style="width: 362px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[0,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,0]]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>
|
||||
上图所示路径的安全系数为 2：
|
||||
- 该路径上距离小偷所在单元格（0，3）最近的单元格是（1，2）。它们之间的曼哈顿距离为 | 0 - 1 | + | 3 - 2 | = 2 。
|
||||
- 该路径上距离小偷所在单元格（3，0）最近的单元格是（3，2）。它们之间的曼哈顿距离为 | 3 - 3 | + | 0 - 2 | = 2 。
|
||||
可以证明，不存在安全系数更高的其他路径。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= grid.length == n <= 400</code></li>
|
||||
<li><code>grid[i].length == n</code></li>
|
||||
<li><code>grid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
<li><code>grid</code> 至少存在一个小偷</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,57 @@
|
||||
<p>给你一个字符串数组 <code>words</code> 和一个字符 <code>separator</code> ，请你按 <code>separator</code> 拆分 <code>words</code> 中的每个字符串。</p>
|
||||
|
||||
<p>返回一个由拆分后的新字符串组成的字符串数组，<strong>不包括空字符串</strong> 。</p>
|
||||
|
||||
<p><strong>注意</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>separator</code> 用于决定拆分发生的位置，但它不包含在结果字符串中。</li>
|
||||
<li>拆分可能形成两个以上的字符串。</li>
|
||||
<li>结果字符串必须保持初始相同的先后顺序。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>words = ["one.two.three","four.five","six"], separator = "."
|
||||
<strong>输出：</strong>["one","two","three","four","five","six"]
|
||||
<strong>解释：</strong>在本示例中，我们进行下述拆分：
|
||||
|
||||
"one.two.three" 拆分为 "one", "two", "three"
|
||||
"four.five" 拆分为 "four", "five"
|
||||
"six" 拆分为 "six"
|
||||
|
||||
因此，结果数组为 ["one","two","three","four","five","six"] 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>words = ["$easy$","$problem$"], separator = "$"
|
||||
<strong>输出：</strong>["easy","problem"]
|
||||
<strong>解释：</strong>在本示例中，我们进行下述拆分：
|
||||
|
||||
"$easy$" 拆分为 "easy"（不包括空字符串）
|
||||
"$problem$" 拆分为 "problem"（不包括空字符串）
|
||||
|
||||
因此，结果数组为 ["easy","problem"] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>words = ["|||"], separator = "|"
|
||||
<strong>输出：</strong>[]
|
||||
<strong>解释：</strong>在本示例中，"|||" 的拆分结果将只包含一些空字符串，所以我们返回一个空数组 [] 。 </pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 100</code></li>
|
||||
<li><code>1 <= words[i].length <= 20</code></li>
|
||||
<li><code>words[i]</code> 中的字符要么是小写英文字母，要么就是字符串 <code>".,|$#@"</code> 中的字符（不包括引号）</li>
|
||||
<li><code>separator</code> 是字符串 <code>".,|$#@"</code> 中的某个字符（不包括引号）</li>
|
||||
</ul>
|
||||
46
leetcode-cn/problem (Chinese)/故障键盘 [faulty-keyboard].html
Normal file
46
leetcode-cn/problem (Chinese)/故障键盘 [faulty-keyboard].html
Normal file
@@ -0,0 +1,46 @@
|
||||
<p>你的笔记本键盘存在故障，每当你在上面输入字符 <code>'i'</code> 时，它会反转你所写的字符串。而输入其他字符则可以正常工作。</p>
|
||||
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串 <code>s</code> ，请你用故障键盘依次输入每个字符。</p>
|
||||
|
||||
<p>返回最终笔记本屏幕上输出的字符串。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "string"
|
||||
<strong>输出：</strong>"rtsng"
|
||||
<strong>解释：</strong>
|
||||
输入第 1 个字符后，屏幕上的文本是："s" 。
|
||||
输入第 2 个字符后，屏幕上的文本是："st" 。
|
||||
输入第 3 个字符后，屏幕上的文本是："str" 。
|
||||
因为第 4 个字符是 'i' ，屏幕上的文本被反转，变成 "rts" 。
|
||||
输入第 5 个字符后，屏幕上的文本是："rtsn" 。
|
||||
输入第 6 个字符后，屏幕上的文本是： "rtsng" 。
|
||||
因此，返回 "rtsng" 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "poiinter"
|
||||
<strong>输出：</strong>"ponter"
|
||||
<strong>解释：</strong>
|
||||
输入第 1 个字符后，屏幕上的文本是："p" 。
|
||||
输入第 2 个字符后，屏幕上的文本是："po" 。
|
||||
因为第 3 个字符是 'i' ，屏幕上的文本被反转，变成 "op" 。
|
||||
因为第 4 个字符是 'i' ，屏幕上的文本被反转，变成 "po" 。
|
||||
输入第 5 个字符后，屏幕上的文本是："pon" 。
|
||||
输入第 6 个字符后，屏幕上的文本是："pont" 。
|
||||
输入第 7 个字符后，屏幕上的文本是："ponte" 。
|
||||
输入第 8 个字符后，屏幕上的文本是："ponter" 。
|
||||
因此，返回 "ponter" 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>s</code> 由小写英文字母组成</li>
|
||||
<li><code>s[0] != 'i'</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>给你一棵 <strong>树</strong>（即，一个连通、无向且无环的图），<strong>根</strong> 节点为 <code>0</code> ，由编号从 <code>0</code> 到 <code>n - 1</code> 的 <code>n</code> 个节点组成。这棵树用一个长度为 <code>n</code> 、下标从 <strong>0</strong> 开始的数组 <code>parent</code> 表示，其中 <code>parent[i]</code> 为节点 <code>i</code> 的父节点，由于节点 <code>0</code> 为根节点，所以 <code>parent[0] == -1</code> 。</p>
|
||||
|
||||
<p>另给你一个长度为 <code>n</code> 的字符串 <code>s</code> ，其中 <code>s[i]</code> 是分配给 <code>i</code> 和 <code>parent[i]</code> 之间的边的字符。<code>s[0]</code> 可以忽略。</p>
|
||||
|
||||
<p>找出满足 <code>u < v</code> ，且从 <code>u</code> 到 <code>v</code> 的路径上分配的字符可以 <strong>重新排列</strong> 形成 <strong>回文</strong> 的所有节点对 <code>(u, v)</code> ，并返回节点对的数目。</p>
|
||||
|
||||
<p>如果一个字符串正着读和反着读都相同，那么这个字符串就是一个 <strong>回文</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/07/15/treedrawio-8drawio.png" style="width: 281px; height: 181px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>parent = [-1,0,0,1,1,2], s = "acaabc"
|
||||
<strong>输出：</strong>8
|
||||
<strong>解释：</strong>符合题目要求的节点对分别是：
|
||||
- (0,1)、(0,2)、(1,3)、(1,4) 和 (2,5) ，路径上只有一个字符，满足回文定义。
|
||||
- (2,3)，路径上字符形成的字符串是 "aca" ，满足回文定义。
|
||||
- (1,5)，路径上字符形成的字符串是 "cac" ，满足回文定义。
|
||||
- (3,5)，路径上字符形成的字符串是 "acac" ，可以重排形成回文 "acca" 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>parent = [-1,0,0,0,0], s = "aaaaa"
|
||||
<strong>输出：</strong>10
|
||||
<strong>解释：</strong>任何满足 u < v 的节点对 (u,v) 都符合题目要求。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == parent.length == s.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li>对于所有 <code>i >= 1</code> ，<code>0 <= parent[i] <= n - 1</code> 均成立</li>
|
||||
<li><code>parent[0] == -1</code></li>
|
||||
<li><code>parent</code> 表示一棵有效的树</li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>给你一个整数数组 <code>nums</code> ，如果它是数组 <code>base[n]</code> 的一个排列，我们称它是个 <strong>好</strong> 数组。</p>
|
||||
|
||||
<p><code>base[n] = [1, 2, ..., n - 1, n, n]</code> （换句话说，它是一个长度为 <code>n + 1</code> 且包含 <code>1</code> 到 <code>n - 1</code> 恰好各一次，包含 <code>n</code> 两次的一个数组）。比方说，<code>base[1] = [1, 1]</code> ，<code>base[3] = [1, 2, 3, 3]</code> 。</p>
|
||||
|
||||
<p>如果数组是一个好数组，请你返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
|
||||
|
||||
<p><strong>注意：</strong>数组的排列是这些数字按任意顺序排布后重新得到的数组。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2, 1, 3]
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>因为数组的最大元素是 3 ，唯一可以构成这个数组的 base[n] 对应的 n = 3 。但是 base[3] 有 4 个元素，但数组 nums 只有 3 个元素，所以无法得到 base[3] = [1, 2, 3, 3] 的排列，所以答案为 false 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1, 3, 3, 2]
|
||||
<b>输出：</b>true
|
||||
<b>解释：因为</b>数组的最大元素是 3 ，唯一可以构成这个数组的 base[n] 对应的 n = 3 ，可以看出数组是 base[3] = [1, 2, 3, 3] 的一个排列（交换 nums 中第二个和第四个元素）。所以答案为 true 。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1, 1]
|
||||
<b>输出：</b>true
|
||||
<b>解释：</b>因为数组的最大元素是 1 ，唯一可以构成这个数组的 base[n] 对应的 n = 1，可以看出数组是 base[1] = [1, 1] 的一个排列。所以答案为 true 。</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [3, 4, 4, 1, 2, 1]
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>因为数组的最大元素是 4 ，唯一可以构成这个数组的 base[n] 对应的 n = 4 。但是 base[n] 有 5 个元素而 nums 有 6 个元素。所以答案为 false 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= num[i] <= 200</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>公司里共有 <code>n</code> 名员工，按从 <code>0</code> 到 <code>n - 1</code> 编号。每个员工 <code>i</code> 已经在公司工作了 <code>hours[i]</code> 小时。</p>
|
||||
|
||||
<p>公司要求每位员工工作 <strong>至少</strong> <code>target</code> 小时。</p>
|
||||
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的非负整数数组 <code>hours</code> 和一个非负整数 <code>target</code> 。</p>
|
||||
|
||||
<p>请你用整数表示并返回工作至少 <code>target</code> 小时的员工数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>hours = [0,1,2,3,4], target = 2
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>公司要求每位员工工作至少 2 小时。
|
||||
- 员工 0 工作 0 小时，不满足要求。
|
||||
- 员工 1 工作 1 小时，不满足要求。
|
||||
- 员工 2 工作 2 小时，满足要求。
|
||||
- 员工 3 工作 3 小时，满足要求。
|
||||
- 员工 4 工作 4 小时，满足要求。
|
||||
共有 3 位满足要求的员工。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>hours = [5,1,4,2,2], target = 6
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>公司要求每位员工工作至少 6 小时。
|
||||
共有 0 位满足要求的员工。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == hours.length <= 50</code></li>
|
||||
<li><code>0 <= hours[i], target <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>给你一个由 <strong>正</strong> 整数组成的数组 <code>nums</code> 。</p>
|
||||
|
||||
<p>如果数组中的某个子数组满足下述条件，则称之为 <strong>完全子数组</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>子数组中 <strong>不同</strong> 元素的数目等于整个数组不同元素的数目。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回数组中 <strong>完全子数组</strong> 的数目。</p>
|
||||
|
||||
<p><strong>子数组</strong> 是数组中的一个连续非空序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [1,3,1,2,2]
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>完全子数组有：[1,3,1,2]、[1,3,1,2,2]、[3,1,2] 和 [3,1,2,2] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [5,5,5,5]
|
||||
<strong>输出：</strong>10
|
||||
<strong>解释：</strong>数组仅由整数 5 组成，所以任意子数组都满足完全子数组的条件。子数组的总数为 10 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 2000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>给你两个正整数 <code>low</code> 和 <code>high</code> ，都用字符串表示，请你统计闭区间 <code>[low, high]</code> 内的 <strong>步进数字</strong> 数目。</p>
|
||||
|
||||
<p>如果一个整数相邻数位之间差的绝对值都 <strong>恰好</strong> 是 <code>1</code> ，那么这个数字被称为 <strong>步进数字</strong> 。</p>
|
||||
|
||||
<p>请你返回一个整数，表示闭区间 <code>[low, high]</code> 之间步进数字的数目。</p>
|
||||
|
||||
<p>由于答案可能很大，请你将它对 <code>10<sup>9</sup> + 7</code> <strong>取余</strong> 后返回。</p>
|
||||
|
||||
<p><b>注意：</b>步进数字不能有前导 0 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>low = "1", high = "11"
|
||||
<b>输出：</b>10
|
||||
<strong>解释：</strong>区间 [1,11] 内的步进数字为 1 ，2 ，3 ，4 ，5 ，6 ，7 ，8 ，9 和 10 。总共有 10 个步进数字。所以输出为 10 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>low = "90", high = "101"
|
||||
<b>输出：</b>2
|
||||
<strong>解释：</strong>区间 [90,101] 内的步进数字为 98 和 101 。总共有 2 个步进数字。所以输出为 2 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= int(low) <= int(high) < 10<sup>100</sup></code></li>
|
||||
<li><code>1 <= low.length, high.length <= 100</code></li>
|
||||
<li><code>low</code> 和 <code>high</code> 只包含数字。</li>
|
||||
<li><code>low</code> 和 <code>high</code> 都不含前导 0 。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> 和一个正整数 <code>x</code> 。</p>
|
||||
|
||||
<p>你 <strong>一开始</strong> 在数组的位置 <code>0</code> 处，你可以按照下述规则访问数组中的其他位置：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果你当前在位置 <code>i</code> ，那么你可以移动到满足 <code>i < j</code> 的 <strong>任意</strong> 位置 <code>j</code> 。</li>
|
||||
<li>对于你访问的位置 <code>i</code> ，你可以获得分数 <code>nums[i]</code> 。</li>
|
||||
<li>如果你从位置 <code>i</code> 移动到位置 <code>j</code> 且 <code>nums[i]</code> 和 <code>nums[j]</code> 的 <strong>奇偶性</strong> 不同，那么你将失去分数 <code>x</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回你能得到的 <strong>最大</strong> 得分之和。</p>
|
||||
|
||||
<p><strong>注意</strong> ，你一开始的分数为 <code>nums[0]</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2,3,6,1,9,2], x = 5
|
||||
<b>输出：</b>13
|
||||
<b>解释：</b>我们可以按顺序访问数组中的位置：0 -> 2 -> 3 -> 4 。
|
||||
对应位置的值为 2 ，6 ，1 和 9 。因为 6 和 1 的奇偶性不同，所以下标从 2 -> 3 让你失去 x = 5 分。
|
||||
总得分为：2 + 6 + 1 + 9 - 5 = 13 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2,4,6,8], x = 3
|
||||
<b>输出：</b>20
|
||||
<b>解释：</b>数组中的所有元素奇偶性都一样，所以我们可以将每个元素都访问一次，而且不会失去任何分数。
|
||||
总得分为：2 + 4 + 6 + 8 = 20 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i], x <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,59 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的数组 <code>usageLimits</code> 。</p>
|
||||
|
||||
<p>你的任务是使用从 <code>0</code> 到 <code>n - 1</code> 的数字创建若干组，并确保每个数字 <code>i</code> 在 <strong>所有组</strong> 中使用的次数总共不超过 <code>usageLimits[i]</code> 次。此外，还必须满足以下条件：</p>
|
||||
|
||||
<ul>
|
||||
<li>每个组必须由 <strong>不同</strong> 的数字组成，也就是说，单个组内不能存在重复的数字。</li>
|
||||
<li>每个组（除了第一个）的长度必须 <strong>严格大于</strong> 前一个组。</li>
|
||||
</ul>
|
||||
|
||||
<p>在满足所有条件的情况下，以整数形式返回可以创建的最大组数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<code><strong>输入：</strong>usageLimits</code> = [1,2,5]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>在这个示例中，我们可以使用 0 至多一次，使用 1 至多 2 次，使用 2 至多 5 次。
|
||||
一种既能满足所有条件，又能创建最多组的方式是：
|
||||
组 1 包含数字 [2] 。
|
||||
组 2 包含数字 [1,2] 。
|
||||
组 3 包含数字 [0,1,2] 。
|
||||
可以证明能够创建的最大组数是 3 。
|
||||
所以，输出是 3 。 </pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<code><strong>输入：</strong></code><code>usageLimits</code> = [2,1,2]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>在这个示例中，我们可以使用 0 至多 2 次，使用 1 至多 1 次，使用 2 至多 2 次。
|
||||
一种既能满足所有条件，又能创建最多组的方式是：
|
||||
组 1 包含数字 [0] 。
|
||||
组 2 包含数字 [1,2] 。
|
||||
可以证明能够创建的最大组数是 2 。
|
||||
所以，输出是 2 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<code><strong>输入：</strong></code><code>usageLimits</code> = [1,1]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>在这个示例中，我们可以使用 0 和 1 至多 1 次。
|
||||
一种既能满足所有条件，又能创建最多组的方式是：
|
||||
组 1 包含数字 [0] 。
|
||||
可以证明能够创建的最大组数是 1 。
|
||||
所以，输出是 1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= usageLimits.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= usageLimits[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user