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>给你一个整数数组 <code>nums</code> 和两个正整数 <code>m</code> 和 <code>k</code> 。</p>
|
||||
|
||||
<p>请你返回 <code>nums</code> 中长度为 <code>k</code> 的 <strong>几乎唯一</strong> 子数组的 <strong>最大和</strong> ，如果不存在几乎唯一子数组，请你返回 <code>0</code> 。</p>
|
||||
|
||||
<p>如果 <code>nums</code> 的一个子数组有至少 <code>m</code> 个互不相同的元素，我们称它是 <strong>几乎唯一</strong> 子数组。</p>
|
||||
|
||||
<p>子数组指的是一个数组中一段连续 <strong>非空</strong> 的元素序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [2,6,7,3,1,7], m = 3, k = 4
|
||||
<b>输出：</b>18
|
||||
<b>解释：</b>总共有 3 个长度为 k = 4 的几乎唯一子数组。分别为 [2, 6, 7, 3] ，[6, 7, 3, 1] 和 [7, 3, 1, 7] 。这些子数组中，和最大的是 [2, 6, 7, 3] ，和为 18 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [5,9,9,2,4,5,4], m = 1, k = 3
|
||||
<b>输出：</b>23
|
||||
<b>解释：</b>总共有 5 个长度为 k = 3 的几乎唯一子数组。分别为 [5, 9, 9] ，[9, 9, 2] ，[9, 2, 4] ，[2, 4, 5] 和 [4, 5, 4] 。这些子数组中，和最大的是 [5, 9, 9] ，和为 23 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,2,1,2,1,2,1], m = 3, k = 3
|
||||
<b>输出：</b>0
|
||||
<b>解释：</b>输入数组中不存在长度为 <code>k = 3</code> 的子数组含有至少 <code>m = 3</code> 个互不相同元素的子数组。所以不存在几乎唯一子数组，最大和为 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= m <= k <= nums.length</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>给你两个字符串 <code>s1</code> 和 <code>s2</code> ，两个字符串的长度都为 <code>4</code> ，且只包含 <strong>小写</strong> 英文字母。</p>
|
||||
|
||||
<p>你可以对两个字符串中的 <strong>任意一个</strong> 执行以下操作 <strong>任意</strong> 次：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择两个下标 <code>i</code> 和 <code>j</code> 且满足 <code>j - i = 2</code> ，然后 <strong>交换</strong> 这个字符串中两个下标对应的字符。</li>
|
||||
</ul>
|
||||
|
||||
<p>如果你可以让字符串<em> </em><code>s1</code><em> </em>和<em> </em><code>s2</code> 相等，那么返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s1 = "abcd", s2 = "cdab"
|
||||
<b>输出：</b>true
|
||||
<strong>解释：</strong> 我们可以对 s1 执行以下操作：
|
||||
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbad" 。
|
||||
- 选择下标 i = 1 ，j = 3 ，得到字符串 s1 = "cdab" = s2 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s1 = "abcd", s2 = "dacb"
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>无法让两个字符串相等。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>s1.length == s2.length == 4</code></li>
|
||||
<li><code>s1</code> 和 <code>s2</code> 只包含小写英文字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>给你两个字符串 <code>s1</code> 和 <code>s2</code> ，两个字符串长度都为 <code>n</code> ，且只包含 <strong>小写 </strong>英文字母。</p>
|
||||
|
||||
<p>你可以对两个字符串中的 <strong>任意一个</strong> 执行以下操作 <strong>任意</strong> 次：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择两个下标 <code>i</code> 和 <code>j</code> ，满足 <code>i < j</code> 且 <code>j - i</code> 是 <strong>偶数</strong>，然后 <strong>交换</strong> 这个字符串中两个下标对应的字符。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>如果你可以让字符串<em> </em><code>s1</code><em> </em>和<em> </em><code>s2</code> 相等，那么返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s1 = "abcdba", s2 = "cabdab"
|
||||
<b>输出：</b>true
|
||||
<b>解释：</b>我们可以对 s1 执行以下操作：
|
||||
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbadba" 。
|
||||
- 选择下标 i = 2 ，j = 4 ，得到字符串 s1 = "cbbdaa" 。
|
||||
- 选择下标 i = 1 ，j = 5 ，得到字符串 s1 = "cabdab" = s2 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s1 = "abe", s2 = "bea"
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>无法让两个字符串相等。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == s1.length == s2.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>s1</code> 和 <code>s2</code> 只包含小写英文字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>现给定一个函数 <code>fn</code> ，一个参数数组 <code>args</code> 和一个以毫秒为单位的超时时间 <code>t</code> ，返回一个取消函数 <code>cancelFn</code> 。</p>
|
||||
|
||||
<p>在经过 <code>t</code> 毫秒的延迟后，应该调用 <code>fn</code> 函数，并将 <code>args</code> 作为参数传递。<strong>除非</strong> 在 <code>t</code> 毫秒的延迟过程中，在 <code>cancelT</code> 毫秒时调用了 <code>cancelFn</code>。并且在这种情况下，<code>fn</code> 函数不应该被调用。</p>
|
||||
|
||||
<p><strong class="example">示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x) => x * 5, args = [2], t = 20, cancelT = 50
|
||||
<b>输出：</b>[{"time": 20, "returned": 10}]
|
||||
<b>解释：</b>
|
||||
const cancel = cancellable((x) => x * 5, [2], 20); // fn(2) 在 t=20ms 时被调用
|
||||
setTimeout(cancel, 50);
|
||||
|
||||
取消操作被安排在延迟了 cancelT（50毫秒）后进行，这发生在 fn(2) 在20毫秒时执行之后。</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x) => x**2, args = [2], t = 100, cancelT = 50
|
||||
<b>输出：</b>[]
|
||||
<b>解释：</b>
|
||||
const cancel = cancellable((x) => x**2, [2], 100); // fn(2) 没被调用
|
||||
setTimeout(cancel, 50);
|
||||
|
||||
取消操作被安排在延迟了 cancelT（50毫秒）后进行，这发生在 fn(2) 在100毫秒时执行之前，导致 fn(2) 从未被调用。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>fn = (x1, x2) => x1 * x2, args = [2,4], t = 30, cancelTime = 100
|
||||
<b>输出：</b>[{"time": 30, "returned": 8}]
|
||||
<b>解释：</b>
|
||||
const cancel = cancellable((x1, x2) => x1 * x2, [2,4], 30); // fn(2,4) 在 t=30ms 时被调用
|
||||
setTimeout(cancel, 100);
|
||||
|
||||
取消操作被安排在延迟了 cancelT（100毫秒）后进行，这发生在 fn(2,4) 在30毫秒时执行之后。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>fn 是一个函数</code></li>
|
||||
<li><code>args 是一个有效的 JSON 数组</code></li>
|
||||
<li><code>1 <= args.length <= 10</code></li>
|
||||
<li><code><font face="monospace">20 <= t <= 1000</font></code></li>
|
||||
<li><code><font face="monospace">10 <= cancelT <= 1000</font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串 <code>num</code> ，表示一个非负整数。</p>
|
||||
|
||||
<p>在一次操作中，您可以选择 <code>num</code> 的任意一位数字并将其删除。请注意，如果你删除 <code>num</code> 中的所有数字，则 <code>num</code> 变为 <code>0</code>。</p>
|
||||
|
||||
<p>返回最少需要多少次操作可以使 <code>num</code> 变成特殊数字。</p>
|
||||
|
||||
<p>如果整数 <code>x</code> 能被 <code>25</code> 整除，则该整数 <code>x</code> 被认为是特殊数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num = "2245047"
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>删除数字 num[5] 和 num[6] ，得到数字 "22450" ，可以被 25 整除。
|
||||
可以证明要使数字变成特殊数字，最少需要删除 2 位数字。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num = "2908305"
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>删除 num[3]、num[4] 和 num[6] ，得到数字 "2900" ，可以被 25 整除。
|
||||
可以证明要使数字变成特殊数字，最少需要删除 3 位数字。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>num = "10"
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>删除 num[0] ，得到数字 "0" ，可以被 25 整除。
|
||||
可以证明要使数字变成特殊数字，最少需要删除 1 位数字。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num.length <= 100</code></li>
|
||||
<li><code>num</code> 仅由数字 <code>'0'</code> 到 <code>'9'</code> 组成</li>
|
||||
<li><code>num</code> 不含任何前导零</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,72 @@
|
||||
<p>给你一个字符串 <code>s</code> 和一个整数 <code>k</code> 。</p>
|
||||
|
||||
<p><strong>k 子序列</strong>指的是 <code>s</code> 的一个长度为 <code>k</code> 的 <strong>子序列</strong> ，且所有字符都是 <strong>唯一</strong> 的，也就是说每个字符在子序列里只出现过一次。</p>
|
||||
|
||||
<p>定义 <code>f(c)</code> 为字符 <code>c</code> 在 <code>s</code> 中出现的次数。</p>
|
||||
|
||||
<p>k 子序列的 <strong>美丽值</strong> 定义为这个子序列中每一个字符 <code>c</code> 的 <code>f(c)</code> 之 <strong>和</strong> 。</p>
|
||||
|
||||
<p>比方说，<code>s = "abbbdd"</code> 和 <code>k = 2</code> ，我们有：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>f('a') = 1</code>, <code>f('b') = 3</code>, <code>f('d') = 2</code></li>
|
||||
<li><code>s</code> 的部分 k 子序列为：
|
||||
<ul>
|
||||
<li><code>"<em><strong>ab</strong></em>bbdd"</code> -> <code>"ab"</code> ，美丽值为 <code>f('a') + f('b') = 4</code></li>
|
||||
<li><code>"<em><strong>a</strong></em>bbb<em><strong>d</strong></em>d"</code> -> <code>"ad"</code> ，美丽值为 <code>f('a') + f('d') = 3</code></li>
|
||||
<li><code>"a<em><strong>b</strong></em>bb<em><strong>d</strong></em>d"</code> -> <code>"bd"</code> ，美丽值为 <code>f('b') + f('d') = 5</code></li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回一个整数，表示所有 <strong>k 子序列 </strong>里面 <strong>美丽值 </strong>是 <strong>最大值</strong> 的子序列数目。由于答案可能很大，将结果对 <code>10<sup>9</sup> + 7</code> 取余后返回。</p>
|
||||
|
||||
<p>一个字符串的子序列指的是从原字符串里面删除一些字符（也可能一个字符也不删除），不改变剩下字符顺序连接得到的新字符串。</p>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>f(c)</code> 指的是字符 <code>c</code> 在字符串 <code>s</code> 的出现次数，不是在 k 子序列里的出现次数。</li>
|
||||
<li>两个 k 子序列如果有任何一个字符在原字符串中的下标不同，则它们是两个不同的子序列。所以两个不同的 k 子序列可能产生相同的字符串。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "bcca", k = 2
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b><span style="white-space: normal">s 中我们有 f('a') = 1 ，f('b') = 1 和 f('c') = 2 。</span>
|
||||
s 的 k 子序列为：
|
||||
<em><strong>bc</strong></em>ca ，美丽值为 f('b') + f('c') = 3
|
||||
<em><strong>b</strong></em>c<em><strong>c</strong></em>a ，美丽值为 f('b') + f('c') = 3
|
||||
<em><strong>b</strong></em>cc<em><strong>a</strong></em> ，美丽值为 f('b') + f('a') = 2
|
||||
b<em><strong>c</strong></em>c<em><strong>a</strong></em><strong> </strong>，美丽值为 f('c') + f('a') = 3
|
||||
bc<em><strong>ca</strong></em> ，美丽值为 f('c') + f('a') = 3
|
||||
总共有 4 个 k 子序列美丽值为最大值 3 。
|
||||
所以答案为 4 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "abbcd", k = 4
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b><span style="white-space: normal">s 中我们有 f('a') = 1 ，f('b') = 2 ，f('c') = 1 和</span> f('d') = 1 。
|
||||
s 的 k 子序列为：
|
||||
<em><strong>ab</strong></em>b<em><strong>cd</strong></em> ，美丽值为 f('a') + f('b') + f('c') + f('d') = 5
|
||||
<span style="white-space: normal;"><b><i>a</i></b></span>b<em><strong>bcd</strong></em> ，美丽值为 f('a') + f('b') + f('c') + f('d') = 5
|
||||
总共有 2 个 k 子序列美丽值为最大值 5 。
|
||||
所以答案为 2 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 2 * 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= s.length</code></li>
|
||||
<li><code>s</code> 只包含小写英文字母。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>给你两个正整数 <code>low</code> 和 <code>high</code> 。</p>
|
||||
|
||||
<p>对于一个由 <code>2 * n</code> 位数字组成的整数 <code>x</code> ，如果其前 <code>n</code> 位数字之和与后 <code>n</code> 位数字之和相等，则认为这个数字是一个对称整数。</p>
|
||||
|
||||
<p>返回在 <code>[low, high]</code> 范围内的 <strong>对称整数的数目</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>low = 1, high = 100
|
||||
<strong>输出：</strong>9
|
||||
<strong>解释：</strong>在 1 到 100 范围内共有 9 个对称整数：11、22、33、44、55、66、77、88 和 99 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>low = 1200, high = 1230
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>在 1200 到 1230 范围内共有 4 个对称整数：1203、1212、1221 和 1230 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= low <= high <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,57 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，以及整数 <code>modulo</code> 和整数 <code>k</code> 。</p>
|
||||
|
||||
<p>请你找出并统计数组中 <strong>趣味子数组</strong> 的数目。</p>
|
||||
|
||||
<p>如果 <strong>子数组</strong> <code>nums[l..r]</code> 满足下述条件，则称其为 <strong>趣味子数组</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>在范围 <code>[l, r]</code> 内，设 <code>cnt</code> 为满足 <code>nums[i] % modulo == k</code> 的索引 <code>i</code> 的数量。并且 <code>cnt % modulo == k</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>以整数形式表示并返回趣味子数组的数目。<em> </em></p>
|
||||
|
||||
<p><span><strong>注意：</strong>子数组是数组中的一个连续非空的元素序列。</span></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,2,4], modulo = 2, k = 1
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>在这个示例中，趣味子数组分别是：
|
||||
子数组 nums[0..0] ，也就是 [3] 。
|
||||
- 在范围 [0, 0] 内，只存在 1 个下标 i = 0 满足 nums[i] % modulo == k 。
|
||||
- 因此 cnt = 1 ，且 cnt % modulo == k 。
|
||||
子数组 nums[0..1] ，也就是 [3,2] 。
|
||||
- 在范围 [0, 1] 内，只存在 1 个下标 i = 0 满足 nums[i] % modulo == k 。
|
||||
- 因此 cnt = 1 ，且 cnt % modulo == k 。
|
||||
子数组 nums[0..2] ，也就是 [3,2,4] 。
|
||||
- 在范围 [0, 2] 内，只存在 1 个下标 i = 0 满足 nums[i] % modulo == k 。
|
||||
- 因此 cnt = 1 ，且 cnt % modulo == k 。
|
||||
可以证明不存在其他趣味子数组。因此，答案为 3 。</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,1,9,6], modulo = 3, k = 0
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>在这个示例中，趣味子数组分别是：
|
||||
子数组 nums[0..3] ，也就是 [3,1,9,6] 。
|
||||
- 在范围 [0, 3] 内，只存在 3 个下标 i = 0, 2, 3 满足 nums[i] % modulo == k 。
|
||||
- 因此 cnt = 3 ，且 cnt % modulo == k 。
|
||||
子数组 nums[1..1] ，也就是 [1] 。
|
||||
- 在范围 [1, 1] 内，不存在下标满足 nums[i] % modulo == k 。
|
||||
- 因此 cnt = 0 ，且 cnt % modulo == k 。
|
||||
可以证明不存在其他趣味子数组，因此答案为 2 。</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>9</sup></code></li>
|
||||
<li><code>1 <= modulo <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= k < modulo</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,54 @@
|
||||
<p>现有一棵由 <code>n</code> 个节点组成的无向树，节点按从 <code>0</code> 到 <code>n - 1</code> 编号。给你一个整数 <code>n</code> 和一个长度为 <code>n - 1</code> 的二维整数数组 <code>edges</code> ，其中 <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> 表示树中存在一条位于节点 <code>u<sub>i</sub></code> 和节点 <code>v<sub>i</sub></code> 之间、权重为 <code>w<sub>i</sub></code> 的边。</p>
|
||||
|
||||
<p>另给你一个长度为 <code>m</code> 的二维整数数组 <code>queries</code> ，其中 <code>queries[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 。对于每条查询，请你找出使从 <code>a<sub>i</sub></code> 到 <code>b<sub>i</sub></code> 路径上每条边的权重相等所需的 <strong>最小操作次数</strong> 。在一次操作中，你可以选择树上的任意一条边，并将其权重更改为任意值。</p>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>查询之间 <strong>相互独立</strong> 的，这意味着每条新的查询时，树都会回到 <strong>初始状态</strong> 。</li>
|
||||
<li>从 <code>a<sub>i</sub></code> 到 <code>b<sub>i</sub></code>的路径是一个由 <strong>不同</strong> 节点组成的序列，从节点 <code>a<sub>i</sub></code> 开始，到节点 <code>b<sub>i</sub></code> 结束，且序列中相邻的两个节点在树中共享一条边。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回一个长度为 <code>m</code> 的数组 <code>answer</code> ，其中 <code>answer[i]</code> 是第 <code>i</code> 条查询的答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/08/11/graph-6-1.png" style="width: 339px; height: 344px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 7, edges = [[0,1,1],[1,2,1],[2,3,1],[3,4,2],[4,5,2],[5,6,2]], queries = [[0,3],[3,6],[2,6],[0,6]]
|
||||
<strong>输出：</strong>[0,0,1,3]
|
||||
<strong>解释：</strong>第 1 条查询，从节点 0 到节点 3 的路径中的所有边的权重都是 1 。因此，答案为 0 。
|
||||
第 2 条查询，从节点 3 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 0 。
|
||||
第 3 条查询，将边 [2,3] 的权重变更为 2 。在这次操作之后，从节点 2 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 1 。
|
||||
第 4 条查询，将边 [0,1]、[1,2]、[2,3] 的权重变更为 2 。在这次操作之后，从节点 0 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 3 。
|
||||
对于每条查询 queries[i] ，可以证明 answer[i] 是使从 a<sub>i</sub> 到 b<sub>i</sub> 的路径中的所有边的权重相等的最小操作次数。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/08/11/graph-9-1.png" style="width: 472px; height: 370px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 8, edges = [[1,2,6],[1,3,4],[2,4,6],[2,5,3],[3,6,6],[3,0,8],[7,0,2]], queries = [[4,6],[0,4],[6,5],[7,4]]
|
||||
<strong>输出：</strong>[1,2,2,3]
|
||||
<strong>解释：</strong>第 1 条查询，将边 [1,3] 的权重变更为 6 。在这次操作之后，从节点 4 到节点 6 的路径中的所有边的权重都是 6 。因此，答案为 1 。
|
||||
第 2 条查询，将边 [0,3]、[3,1] 的权重变更为 6 。在这次操作之后，从节点 0 到节点 4 的路径中的所有边的权重都是 6 。因此，答案为 2 。
|
||||
第 3 条查询，将边 [1,3]、[5,2] 的权重变更为 6 。在这次操作之后，从节点 6 到节点 5 的路径中的所有边的权重都是 6 。因此，答案为 2 。
|
||||
第 4 条查询，将边 [0,7]、[0,3]、[1,3] 的权重变更为 6 。在这次操作之后，从节点 7 到节点 4 的路径中的所有边的权重都是 6 。因此，答案为 3 。
|
||||
对于每条查询 queries[i] ，可以证明 answer[i] 是使从 a<sub>i</sub> 到 b<sub>i</sub> 的路径中的所有边的权重相等的最小操作次数。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>edges[i].length == 3</code></li>
|
||||
<li><code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code></li>
|
||||
<li><code>1 <= w<sub>i</sub> <= 26</code></li>
|
||||
<li>生成的输入满足 <code>edges</code> 表示一棵有效的树</li>
|
||||
<li><code>1 <= queries.length == m <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>queries[i].length == 2</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user