mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-05 07:21:40 +08:00
update
This commit is contained in:
@@ -0,0 +1,43 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，其中 <code>words[i]</code> 要么是一个字符串形式的正整数，要么是字符串 <code>"prev"</code> 。</p>
|
||||
|
||||
<p>我们从数组的开头开始遍历，对于 <code>words</code> 中的每个 <code>"prev"</code> 字符串，找到 <code>words</code> 中的 <strong>上一个遍历的整数</strong> ，定义如下：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>k</code> 表示到当前位置为止的连续 <code>"prev"</code> 字符串数目（包含当前字符串），令下标从 <strong>0</strong> 开始的 <strong>整数</strong> 数组 <code>nums</code> 表示目前为止遍历过的所有整数，同时用 <code>nums_reverse</code> 表示 <code>nums</code> 反转得到的数组，那么当前 <code>"prev"</code> 对应的 <strong>上一个遍历的整数</strong> 是 <code>nums_reverse</code> 数组中下标为 <code>(k - 1)</code> 的整数。</li>
|
||||
<li>如果 <code>k</code> 比目前为止遍历过的整数数目 <strong>更多</strong> ，那么上一个遍历的整数为 <code>-1</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回一个整数数组，包含所有上一个遍历的整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b><code>words</code> = ["1","2","prev","prev","prev"]
|
||||
<b>输出：</b>[2,1,-1]
|
||||
<b>解释：</b>
|
||||
对于下标为 2 处的 "prev" ，上一个遍历的整数是 2 ，因为连续 "prev" 数目为 1 ，同时在数组 reverse_nums 中，第一个元素是 2 。
|
||||
对于下标为 3 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev" 数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
|
||||
对于下标为 4 处的 "prev" ，上一个遍历的整数是 -1 ，因为连续 "prev" 数目为 3 ，但总共只遍历过 2 个整数。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b><code>words</code> = ["1","prev","2","prev","prev"]
|
||||
<b>输出：</b>[1,2,1]
|
||||
<strong>解释：</strong>
|
||||
对于下标为 1 处的 "prev" ，上一个遍历的整数是 1 。
|
||||
对于下标为 3 处的 "prev" ，上一个遍历的整数是 2 。
|
||||
对于下标为 4 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev"<strong> </strong>数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 100</code></li>
|
||||
<li><code>words[i] == "prev"</code> 或 <code>1 <= int(words[i]) <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>给你两个正整数 <code>n</code> 和 <code>m</code> 。</p>
|
||||
|
||||
<p>现定义两个整数 <code>num1</code> 和 <code>num2</code> ，如下所示：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>num1</code>：范围 <code>[1, n]</code> 内所有 <strong>无法被 </strong><code>m</code><strong> 整除</strong> 的整数之和。</li>
|
||||
<li><code>num2</code>：范围 <code>[1, n]</code> 内所有 <strong>能够被 </strong><code>m</code><strong> 整除</strong> 的整数之和。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回整数 <code>num1 - num2</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 10, m = 3
|
||||
<strong>输出：</strong>19
|
||||
<strong>解释：</strong>在这个示例中：
|
||||
- 范围 [1, 10] 内无法被 3 整除的整数为 [1,2,4,5,7,8,10] ，num1 = 这些整数之和 = 37 。
|
||||
- 范围 [1, 10] 内能够被 3 整除的整数为 [3,6,9] ，num2 = 这些整数之和 = 18 。
|
||||
返回 37 - 18 = 19 作为答案。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5, m = 6
|
||||
<strong>输出：</strong>15
|
||||
<strong>解释：</strong>在这个示例中：
|
||||
- 范围 [1, 5] 内无法被 6 整除的整数为 [1,2,3,4,5] ，num1 = 这些整数之和 = 15 。
|
||||
- 范围 [1, 5] 内能够被 6 整除的整数为 [] ，num2 = 这些整数之和 = 0 。
|
||||
返回 15 - 0 = 15 作为答案。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5, m = 1
|
||||
<strong>输出：</strong>-15
|
||||
<strong>解释：</strong>在这个示例中：
|
||||
- 范围 [1, 5] 内无法被 1 整除的整数为 [] ，num1 = 这些整数之和 = 0 。
|
||||
- 范围 [1, 5] 内能够被 1 整除的整数为 [1,2,3,4,5] ，num2 = 这些整数之和 = 15 。
|
||||
返回 0 - 15 = -15 作为答案。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n, m <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的非负整数数组 <code>nums</code> 和两个整数 <code>l</code> 和 <code>r</code> 。</p>
|
||||
|
||||
<p>请你返回 <code>nums</code> 中子多重集合的和在闭区间 <code>[l, r]</code> 之间的 <strong>子多重集合的数目</strong> 。</p>
|
||||
|
||||
<p>由于答案可能很大，请你将答案对 <code>10<sup>9 </sup>+ 7</code> 取余后返回。</p>
|
||||
|
||||
<p><strong>子多重集合</strong> 指的是从数组中选出一些元素构成的 <strong>无序</strong> 集合，每个元素 <code>x</code> 出现的次数可以是 <code>0, 1, ..., occ[x]</code> 次，其中 <code>occ[x]</code> 是元素 <code>x</code> 在数组中的出现次数。</p>
|
||||
|
||||
<p><b>注意：</b></p>
|
||||
|
||||
<ul>
|
||||
<li>如果两个子多重集合中的元素排序后一模一样，那么它们两个是相同的 <strong>子多重集合</strong> 。</li>
|
||||
<li><strong>空</strong> 集合的和是 <code>0</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,2,2,3], l = 6, r = 6
|
||||
<b>输出：</b>1
|
||||
<b>解释：</b>唯一和为 6 的子集合是 {1, 2, 3} 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [2,1,4,2,7], l = 1, r = 5
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>和在闭区间 [1, 5] 之间的子多重集合为 {1} ，{2} ，{4} ，{2, 2} ，{1, 2} ，{1, 4} 和 {1, 2, 2} 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,2,1,3,5,2], l = 3, r = 5
|
||||
<b>输出：</b>9
|
||||
<b>解释：</b>和在闭区间 [3, 5] 之间的子多重集合为 {3} ，{5} ，{1, 2} ，{1, 3} ，{2, 2} ，{2, 3} ，{1, 1, 2} ，{1, 1, 3} 和 {1, 2, 2} 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>nums</code> 的和不超过 <code>2 * 10<sup>4</sup></code> 。</li>
|
||||
<li><code>0 <= l <= r <= 2 * 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> 和一个 <strong>正</strong> 整数 <code>k</code> 。</p>
|
||||
|
||||
<p>你可以对数组执行以下操作 <strong>任意次</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择两个互不相同的下标 <code>i</code> 和 <code>j</code> ，<strong>同时</strong> 将 <code>nums[i]</code> 更新为 <code>(nums[i] AND nums[j])</code> 且将 <code>nums[j]</code> 更新为 <code>(nums[i] OR nums[j])</code> ，<code>OR</code> 表示按位 <strong>或</strong> 运算，<code>AND</code> 表示按位 <strong>与</strong> 运算。</li>
|
||||
</ul>
|
||||
|
||||
<p>你需要从最终的数组里选择 <code>k</code> 个元素，并计算它们的 <strong>平方</strong> 之和。</p>
|
||||
|
||||
<p>请你返回你可以得到的 <strong>最大</strong> 平方和。</p>
|
||||
|
||||
<p>由于答案可能会很大，将答案对 <code>10<sup>9</sup> + 7</code> <strong>取余</strong> 后返回。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [2,6,5,8], k = 2
|
||||
<b>输出：</b>261
|
||||
<b>解释：</b>我们可以对数组执行以下操作：
|
||||
- 选择 i = 0 和 j = 3 ，同时将 nums[0] 变为 (2 AND 8) = 0 且 nums[3] 变为 (2 OR 8) = 10 ，结果数组为 nums = [0,6,5,10] 。
|
||||
- 选择 i = 2 和 j = 3 ，同时将 nums[2] 变为 (5 AND 10) = 0 且 nums[3] 变为 (5 OR 10) = 15 ，结果数组为 nums = [0,6,0,15] 。
|
||||
从最终数组里选择元素 15 和 6 ，平方和为 15<sup>2</sup> + 6<sup>2</sup> = 261 。
|
||||
261 是可以得到的最大结果。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [4,5,4,7], k = 3
|
||||
<b>输出：</b>90
|
||||
<b>解释：</b>不需要执行任何操作。
|
||||
选择元素 7 ，5 和 4 ，平方和为 7<sup>2</sup> + 5<sup>2</sup> + 4<sup>2</sup> = 90 。
|
||||
90 是可以得到的最大结果。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>给你两个下标从 <strong>0</strong> 开始的二进制字符串 <code>s1</code> 和 <code>s2</code> ，两个字符串的长度都是 <code>n</code> ，再给你一个正整数 <code>x</code> 。</p>
|
||||
|
||||
<p>你可以对字符串 <code>s1</code> 执行以下操作 <strong>任意次</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择两个下标 <code>i</code> 和 <code>j</code> ，将 <code>s1[i]</code> 和 <code>s1[j]</code> 都反转，操作的代价为 <code>x</code> 。</li>
|
||||
<li>选择满足 <code>i < n - 1</code> 的下标 <code>i</code> ，反转 <code>s1[i]</code> 和 <code>s1[i + 1]</code> ，操作的代价为 <code>1</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回使字符串 <code>s1</code> 和 <code>s2</code> 相等的 <strong>最小</strong> 操作代价之和，如果无法让二者相等，返回 <code>-1</code> 。</p>
|
||||
|
||||
<p><strong>注意</strong> ，反转字符的意思是将 <code>0</code> 变成 <code>1</code> ，或者 <code>1</code> 变成 <code>0</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s1 = "1100011000", s2 = "0101001010", x = 2
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b>我们可以执行以下操作：
|
||||
- 选择 i = 3 执行第二个操作。结果字符串是 s1 = "110<em><strong>11</strong></em>11000" 。
|
||||
- 选择 i = 4 执行第二个操作。结果字符串是 s1 = "1101<em><strong>00</strong></em>1000" 。
|
||||
- 选择 i = 0 和 j = 8 ，执行第一个操作。结果字符串是 s1 = "<em><strong>0</strong></em>1010010<em><strong>1</strong></em>0" = s2 。
|
||||
总代价是 1 + 1 + 2 = 4 。这是最小代价和。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s1 = "10110", s2 = "00011", x = 4
|
||||
<b>输出：</b>-1
|
||||
<b>解释：</b>无法使两个字符串相等。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == s1.length == s2.length</code></li>
|
||||
<li><code>1 <= n, x <= 500</code></li>
|
||||
<li><code>s1</code> 和 <code>s2</code> 只包含字符 <code>'0'</code> 和 <code>'1'</code> 。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的整数数组 <code>nums</code> ，以及整数 <code>indexDifference</code> 和整数 <code>valueDifference</code> 。</p>
|
||||
|
||||
<p>你的任务是从范围 <code>[0, n - 1]</code> 内找出 <strong>2</strong> 个满足下述所有条件的下标 <code>i</code> 和 <code>j</code> ：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>abs(i - j) >= indexDifference</code> 且</li>
|
||||
<li><code>abs(nums[i] - nums[j]) >= valueDifference</code></li>
|
||||
</ul>
|
||||
|
||||
<p>返回整数数组 <code>answer</code>。如果存在满足题目要求的两个下标，则 <code>answer = [i, j]</code> ；否则，<code>answer = [-1, -1]</code> 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。</p>
|
||||
|
||||
<p><strong>注意：</strong><code>i</code> 和 <code>j</code> 可能 <strong>相等</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
|
||||
<strong>输出：</strong>[0,3]
|
||||
<strong>解释：</strong>在示例中，可以选择 i = 0 和 j = 3 。
|
||||
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
|
||||
因此，[0,3] 是一个符合题目要求的答案。
|
||||
[3,0] 也是符合题目要求的答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,1], indexDifference = 0, valueDifference = 0
|
||||
<strong>输出：</strong>[0,0]
|
||||
<strong>解释：</strong>
|
||||
在示例中，可以选择 i = 0 和 j = 0 。
|
||||
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。
|
||||
因此，[0,0] 是一个符合题目要求的答案。
|
||||
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3], indexDifference = 2, valueDifference = 4
|
||||
<strong>输出：</strong>[-1,-1]
|
||||
<strong>解释：</strong>在示例中，可以证明无法找出 2 个满足所有条件的下标。
|
||||
因此，返回 [-1,-1] 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 100</code></li>
|
||||
<li><code>0 <= nums[i] <= 50</code></li>
|
||||
<li><code>0 <= indexDifference <= 100</code></li>
|
||||
<li><code>0 <= valueDifference <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、长度为 <code>n</code> 的整数数组 <code>nums</code> ，以及整数 <code>indexDifference</code> 和整数 <code>valueDifference</code> 。</p>
|
||||
|
||||
<p>你的任务是从范围 <code>[0, n - 1]</code> 内找出 <strong>2</strong> 个满足下述所有条件的下标 <code>i</code> 和 <code>j</code> ：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>abs(i - j) >= indexDifference</code> 且</li>
|
||||
<li><code>abs(nums[i] - nums[j]) >= valueDifference</code></li>
|
||||
</ul>
|
||||
|
||||
<p>返回整数数组 <code>answer</code>。如果存在满足题目要求的两个下标，则 <code>answer = [i, j]</code> ；否则，<code>answer = [-1, -1]</code> 。如果存在多组可供选择的下标对，只需要返回其中任意一组即可。</p>
|
||||
|
||||
<p><strong>注意：</strong><code>i</code> 和 <code>j</code> 可能 <strong>相等</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [5,1,4,1], indexDifference = 2, valueDifference = 4
|
||||
<strong>输出：</strong>[0,3]
|
||||
<strong>解释：</strong>在示例中，可以选择 i = 0 和 j = 3 。
|
||||
abs(0 - 3) >= 2 且 abs(nums[0] - nums[3]) >= 4 。
|
||||
因此，[0,3] 是一个符合题目要求的答案。
|
||||
[3,0] 也是符合题目要求的答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,1], indexDifference = 0, valueDifference = 0
|
||||
<strong>输出：</strong>[0,0]
|
||||
<strong>解释：</strong>
|
||||
在示例中，可以选择 i = 0 和 j = 0 。
|
||||
abs(0 - 0) >= 0 且 abs(nums[0] - nums[0]) >= 0 。
|
||||
因此，[0,0] 是一个符合题目要求的答案。
|
||||
[0,1]、[1,0] 和 [1,1] 也是符合题目要求的答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3], indexDifference = 2, valueDifference = 4
|
||||
<strong>输出：</strong>[-1,-1]
|
||||
<strong>解释：</strong>在示例中，可以证明无法找出 2 个满足所有条件的下标。
|
||||
因此，返回 [-1,-1] 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= indexDifference <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= valueDifference <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>你有 <code>n</code> 颗处理器，每颗处理器都有 <code>4</code> 个核心。现有 <code>n * 4</code> 个待执行任务，每个核心只执行 <strong>一个</strong> 任务。</p>
|
||||
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>processorTime</code> ，表示每颗处理器最早空闲时间。另给你一个下标从 <strong>0</strong> 开始的整数数组 <code>tasks</code> ，表示执行每个任务所需的时间。返回所有任务都执行完毕需要的 <strong>最小时间</strong> 。</p>
|
||||
|
||||
<p>注意：每个核心独立执行任务。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
|
||||
<strong>输出：</strong>16
|
||||
<strong>解释：</strong>
|
||||
最优的方案是将下标为 4, 5, 6, 7 的任务分配给第一颗处理器（最早空闲时间 time = 8），下标为 0, 1, 2, 3 的任务分配给第二颗处理器（最早空闲时间 time = 10）。
|
||||
第一颗处理器执行完所有任务需要花费的时间 = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16 。
|
||||
第二颗处理器执行完所有任务需要花费的时间 = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13 。
|
||||
因此，可以证明执行完所有任务需要花费的最小时间是 16 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
|
||||
<strong>输出：</strong>23
|
||||
<strong>解释：</strong>
|
||||
最优的方案是将下标为 1, 4, 5, 6 的任务分配给第一颗处理器（最早空闲时间 time = 10），下标为 0, 2, 3, 7 的任务分配给第二颗处理器（最早空闲时间 time = 20）。
|
||||
第一颗处理器执行完所有任务需要花费的时间 = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18 。
|
||||
第二颗处理器执行完所有任务需要花费的时间 = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23 。
|
||||
因此，可以证明执行完所有任务需要花费的最小时间是 23 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == processorTime.length <= 25000</code></li>
|
||||
<li><code>1 <= tasks.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= processorTime[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= tasks[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>tasks.length == 4 * n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,62 @@
|
||||
<p>给你一个二进制字符串 <code>s</code> 和一个正整数 <code>k</code> 。</p>
|
||||
|
||||
<p>如果 <code>s</code> 的某个子字符串中 <code>1</code> 的个数恰好等于 <code>k</code> ，则称这个子字符串是一个 <strong>美丽子字符串</strong> 。</p>
|
||||
|
||||
<p>令 <code>len</code> 等于 <strong>最短</strong> 美丽子字符串的长度。</p>
|
||||
|
||||
<p>返回长度等于 <code>len</code> 且字典序 <strong>最小</strong> 的美丽子字符串。如果 <code>s</code> 中不含美丽子字符串，则返回一个 <strong>空</strong> 字符串。</p>
|
||||
|
||||
<p>对于相同长度的两个字符串 <code>a</code> 和 <code>b</code> ，如果在 <code>a</code> 和 <code>b</code> 出现不同的第一个位置上，<code>a</code> 中该位置上的字符严格大于 <code>b</code> 中的对应字符，则认为字符串 <code>a</code> 字典序 <strong>大于</strong> 字符串 <code>b</code> 。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>"abcd"</code> 的字典序大于 <code>"abcc"</code> ，因为两个字符串出现不同的第一个位置对应第四个字符，而 <code>d</code> 大于 <code>c</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "100011001", k = 3
|
||||
<strong>输出：</strong>"11001"
|
||||
<strong>解释：</strong>示例中共有 7 个美丽子字符串：
|
||||
1. 子字符串 "<em><strong>100011</strong></em>001" 。
|
||||
2. 子字符串 "<strong><em>1000110</em></strong>01" 。
|
||||
3. 子字符串 "<strong><em>100011001</em></strong>" 。
|
||||
4. 子字符串 "1<strong><em>00011001</em></strong>" 。
|
||||
5. 子字符串 "10<strong><em>0011001</em></strong>" 。
|
||||
6. 子字符串 "100<em><strong>011001</strong></em>" 。
|
||||
7. 子字符串 "1000<strong><em>11001</em></strong>" 。
|
||||
最短美丽子字符串的长度是 5 。
|
||||
长度为 5 且字典序最小的美丽子字符串是子字符串 "11001" 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "1011", k = 2
|
||||
<strong>输出：</strong>"11"
|
||||
<strong>解释：</strong>示例中共有 3 个美丽子字符串：
|
||||
1. 子字符串 "<em><strong>101</strong></em>1" 。
|
||||
2. 子字符串 "1<em><strong>011</strong></em>" 。
|
||||
3. 子字符串 "10<em><strong>11</strong></em>" 。
|
||||
最短美丽子字符串的长度是 2 。
|
||||
长度为 2 且字典序最小的美丽子字符串是子字符串 "11" 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "000", k = 1
|
||||
<strong>输出：</strong>""
|
||||
<strong>解释：</strong>示例中不存在美丽子字符串。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>1 <= k <= s.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>给你一个整数 <code>n</code> 和一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，和一个下标从 <strong>0</strong> 开始的 <strong>二进制</strong> 数组 <code>groups</code> ，两个数组长度都是 <code>n</code> 。</p>
|
||||
|
||||
<p>你需要从下标 <code>[0, 1, ..., n - 1]</code> 中选出一个 <strong>最长子序列</strong> ，将这个子序列记作长度为 <code>k</code> 的 <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> ，对于所有满足 <code>0 < j + 1 < k</code> 的 <code>j</code> 都有 <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code> 。</p>
|
||||
|
||||
<p>请你返回一个字符串数组，它是下标子序列 <strong>依次</strong> 对应 <code>words</code> 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。</p>
|
||||
|
||||
<p><strong>子序列</strong> 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。</p>
|
||||
|
||||
<p><b>注意：</b><code>words</code> 中的字符串长度可能 <strong>不相等</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 3, words = ["e","a","b"], groups = [0,0,1]
|
||||
<b>输出：</b>["e","b"]
|
||||
<strong>解释：</strong>一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
|
||||
所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
|
||||
另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
|
||||
得到答案为 [words[1],words[2]] = ["a","b"] 。
|
||||
这也是一个可行的答案。
|
||||
符合题意的最长子序列的长度为 2 。</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 4, words = ["a","b","c","d"], groups = [1,0,1,1]
|
||||
<b>输出：</b>["a","b","c"]
|
||||
<b>解释：</b>一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
|
||||
所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
|
||||
另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
|
||||
得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
|
||||
这也是一个可行的答案。
|
||||
符合题意的最长子序列的长度为 3 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == words.length == groups.length <= 100</code></li>
|
||||
<li><code>1 <= words[i].length <= 10</code></li>
|
||||
<li><code>0 <= groups[i] < 2</code></li>
|
||||
<li><code>words</code> 中的字符串 <strong>互不相同</strong> 。</li>
|
||||
<li><code>words[i]</code> 只包含小写英文字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,57 @@
|
||||
<p>给你一个整数 <code>n</code> 和一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，和一个下标从 <strong>0</strong> 开始的 <strong>二进制</strong> 数组 <code>groups</code> ，两个数组长度都是 <code>n</code> 。</p>
|
||||
|
||||
<p>两个长度相等字符串的 <strong>汉明距离</strong> 定义为对应位置字符 <strong>不同</strong> 的数目。</p>
|
||||
|
||||
<p>你需要从下标 <code>[0, 1, ..., n - 1]</code> 中选出一个 <strong>最长子序列</strong> ，将这个子序列记作长度为 <code>k</code> 的 <code>[i<sub>0</sub>, i<sub>1</sub>, ..., i<sub>k - 1</sub>]</code> ，它需要满足以下条件：</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>相邻</strong> 下标对应的 <code>groups</code> 值 <strong>不同</strong>。即，对于所有满足 <code>0 < j + 1 < k</code> 的 <code>j</code> 都有 <code>groups[i<sub>j</sub>] != groups[i<sub>j + 1</sub>]</code> 。</li>
|
||||
<li>对于所有 <code>0 < j + 1 < k</code> 的下标 <code>j</code> ，都满足 <code>words[i<sub>j</sub>]</code> 和 <code>words[i<sub>j + 1</sub>]</code> 的长度 <strong>相等</strong> ，且两个字符串之间的 <strong>汉明距离</strong> 为 <code>1</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回一个字符串数组，它是下标子序列 <strong>依次</strong> 对应 <code>words</code> 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。</p>
|
||||
|
||||
<p><strong>子序列</strong> 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。</p>
|
||||
|
||||
<p><b>注意：</b><code>words</code> 中的字符串长度可能 <strong>不相等</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 3, words = ["bab","dab","cab"], groups = [1,2,2]
|
||||
<b>输出：</b>["bab","cab"]
|
||||
<b>解释：</b>一个可行的子序列是 [0,2] 。
|
||||
- groups[0] != groups[2]
|
||||
- words[0].length == words[2].length 且它们之间的汉明距离为 1 。
|
||||
所以一个可行的答案是 [words[0],words[2]] = ["bab","cab"] 。
|
||||
另一个可行的子序列是 [0,1] 。
|
||||
- groups[0] != groups[1]
|
||||
- words[0].length = words[1].length 且它们之间的汉明距离为 1 。
|
||||
所以另一个可行的答案是 [words[0],words[1]] = ["bab","dab"] 。
|
||||
符合题意的最长子序列的长度为 2 。</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 4, words = ["a","b","c","d"], groups = [1,2,3,4]
|
||||
<b>输出：</b>["a","b","c","d"]
|
||||
<b>解释：</b>我们选择子序列 [0,1,2,3] 。
|
||||
它同时满足两个条件。
|
||||
所以答案为 [words[0],words[1],words[2],words[3]] = ["a","b","c","d"] 。
|
||||
它是所有下标子序列里最长且满足所有条件的。
|
||||
所以它是唯一的答案。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><b>提示：</b></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == words.length == groups.length <= 1000</code></li>
|
||||
<li><code>1 <= words[i].length <= 10</code></li>
|
||||
<li><code>1 <= groups[i] <= n</code></li>
|
||||
<li><code>words</code> 中的字符串 <strong>互不相同</strong> 。</li>
|
||||
<li><code>words[i]</code> 只包含小写英文字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始、大小为 <code>n * m</code> 的二维整数矩阵 <code><font face="monospace">grid</font></code><font face="monospace"> ，定义一个下标从 <strong>0</strong> 开始、大小为 <code>n * m</code> 的的二维矩阵</font> <code>p</code>。如果满足以下条件，则称 <code>p</code> 为 <code>grid</code> 的 <strong>乘积矩阵</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>对于每个元素 <code>p[i][j]</code> ，它的值等于除了 <code>grid[i][j]</code> 外所有元素的乘积。乘积对 <code>12345</code> 取余数。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回 <code>grid</code> 的乘积矩阵。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[1,2],[3,4]]
|
||||
<strong>输出：</strong>[[24,12],[8,6]]
|
||||
<strong>解释：</strong>p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
|
||||
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
|
||||
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
|
||||
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
|
||||
所以答案是 [[24,12],[8,6]] 。</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[12345],[2],[1]]
|
||||
<strong>输出：</strong>[[2],[0],[0]]
|
||||
<strong>解释：</strong>p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2
|
||||
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0 ，所以 p[0][1] = 0
|
||||
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0 ，所以 p[0][2] = 0
|
||||
所以答案是 [[2],[0],[0]] 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == grid.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= m == grid[i].length <= 10<sup>5</sup></code></li>
|
||||
<li><code>2 <= n * m <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= grid[i][j] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user