提交 8d4af9c5 编写于 作者: 每日一练社区's avatar 每日一练社区

add exercises

上级 2170b8b3

要显示的变更太多。

To preserve performance only 1000 of 1000+ files are displayed.
<p>在 <code>N x N</code> 的网格 <code>grid</code> 上,每个单元格都有一盏灯,最初灯都处于 <strong>关闭</strong> 状态。</p>
<p>数组 <code>lamps</code> 表示打开的灯的位置。<code>lamps[i] = [row<sub>i</sub>, col<sub>i</sub>]</code> 表示 <strong>打开</strong> 位于 <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code> 的第 <code>i</code> 盏灯 。每盏灯都照亮自身单元格以及同一行、同一列和两条对角线上的所有其他单元格。</p>
<p>查询数组 <code>queries</code> 中,第 <code>i</code> 次查询 <code>queries[i] = [row<sub>i</sub>, col<sub>i</sub>]</code>,如果单元格 <code>[row<sub>i</sub>, col<sub>i</sub>]</code> 是被照亮的,则查询结果为 <code>1</code> ,否则为 <code>0</code> 。在第 <code>i</code> 次查询之后 [按照查询的顺序] ,<strong>关闭</strong> 位于单元格 <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code> 上或其相邻 8 个方向上(与单元格 <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code> 共享角或边)的任何灯。</p>
<p>返回答案数组 <code>ans</code><code>answer[i]</code> 应等于第 <code>i</code> 次查询 <code>queries[i]</code> 的结果,<code>1</code> 表示照亮,<code>0</code> 表示未照亮。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/19/illu_1.jpg" style="width: 750px; height: 209px;" />
<pre>
<strong>输入:</strong>N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
<strong>输出:</strong>[1,0]
<strong>解释:</strong>最初所有灯都是关闭的。在执行查询之前,打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮(蓝色方框)。该单元格被照亮,所以 ans[0] = 1 。然后,关闭红色方框中的所有灯。
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/19/illu_step1.jpg" style="width: 500px; height: 218px;" />
第 1 次查询检查 grid[1][0] 是否被照亮(蓝色方框)。该单元格没有被照亮,所以 ans[1] = 0 。然后,关闭红色矩形中的所有灯。
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/19/illu_step2.jpg" style="width: 500px; height: 219px;" />
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]
<strong>输出:</strong>[1,1]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>N = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]]
<strong>输出:</strong>[1,1,0]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= N <= 10<sup>9</sup></code></li>
<li><code>0 <= lamps.length <= 20000</code></li>
<li><code>lamps[i].length == 2</code></li>
<li><code>0 <= lamps[i][j] < N</code></li>
<li><code>0 <= queries.length <= 20000</code></li>
<li><code>queries[i].length == 2</code></li>
<li><code>0 <= queries[i][j] < N</code></li>
</ul>
给你一个字符串数组 <code>words</code> ,请你找出所有在 <code>words</code> 的每个字符串中都出现的共用字符( <strong>包括重复字符</strong>),并以数组形式返回。你可以按 <strong>任意顺序</strong> 返回答案。
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>words = ["bella","label","roller"]
<strong>输出:</strong>["e","l","l"]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>words = ["cool","lock","cook"]
<strong>输出:</strong>["c","o"]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= words.length &lt;= 100</code></li>
<li><code>1 &lt;= words[i].length &lt;= 100</code></li>
<li><code>words[i]</code> 由小写英文字母组成</li>
</ul>
给你一个字符串 <code>s</code> ,请你判断它是否 <strong>有效</strong>
<p>字符串 <code>s</code> <strong>有效</strong> 需要满足:假设开始有一个空字符串 <code>t = ""</code> ,你可以执行 <strong>任意次</strong> 下述操作将<strong> </strong><code>t</code><strong> 转换为 </strong><code>s</code></p>
<ul>
<li>将字符串 <code>"abc"</code> 插入到 <code>t</code> 中的任意位置。形式上,<code>t</code> 变为 <code>t<sub>left</sub> + "abc" + t<sub>right</sub></code>,其中 <code>t == t<sub>left</sub> + t<sub>right</sub></code> 。注意,<code>t<sub>left</sub></code><code>t<sub>right</sub></code> 可能为 <strong></strong></li>
</ul>
<p>如果字符串 <code>s</code> 有效,则返回 <code>true</code>;否则,返回 <code>false</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "aabcbc"
<strong>输出:</strong>true
<strong>解释:</strong>
"" -> "<strong>abc</strong>" -> "a<strong>abc</strong>bc"
因此,"aabcbc" 有效。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "abcabcababcc"
<strong>输出:</strong>true
<strong>解释:</strong>
"" -> "<strong>abc</strong>" -> "abc<strong>abc</strong>" -> "abcabc<strong>abc</strong>" -> "abcabcab<strong>abc</strong>c"
因此,"abcabcababcc" 有效。</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "abccba"
<strong>输出:</strong>false
<strong>解释:</strong>执行操作无法得到 "abccba" 。</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>s = "cababc"
<strong>输出:</strong>false
<strong>解释:</strong>执行操作无法得到 "cababc" 。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 2 * 10<sup>4</sup></code></li>
<li><code>s</code> 由字母 <code>'a'</code><code>'b'</code><code>'c'</code> 组成</li>
</ul>
<p>给定一个由若干 <code>0</code><code>1</code> 组成的数组&nbsp;<code>A</code>,我们最多可以将&nbsp;<code>K</code>&nbsp;个值从 0 变成 1 。</p>
<p>返回仅包含 1 的最长(连续)子数组的长度。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
<strong>输出:</strong>6
<strong>解释: </strong>
[1,1,1,0,0,<strong>1</strong>,1,1,1,1,<strong>1</strong>]
粗体数字从 0 翻转到 1,最长的子数组长度为 6。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
<strong>输出:</strong>10
<strong>解释:</strong>
[0,0,1,1,<strong>1</strong>,<strong>1</strong>,1,1,1,<strong>1</strong>,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1,最长的子数组长度为 10。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= A.length &lt;= 20000</code></li>
<li><code>0 &lt;= K &lt;= A.length</code></li>
<li><code>A[i]</code>&nbsp;<code>0</code>&nbsp;&nbsp;<code>1</code>&nbsp;</li>
</ol>
<p>给定一个整数数组 A,我们<strong>只能</strong>用以下方法修改该数组:我们选择某个索引 <code>i</code>&nbsp;并将 <code>A[i]</code> 替换为 <code>-A[i]</code>,然后总共重复这个过程 <code>K</code> 次。(我们可以多次选择同一个索引 <code>i</code>。)</p>
<p>以这种方式修改数组后,返回数组可能的最大和。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>A = [4,2,3], K = 1
<strong>输出:</strong>5
<strong>解释:</strong>选择索引 (1,) ,然后 A 变为 [4,-2,3]。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>A = [3,-1,0,2], K = 3
<strong>输出:</strong>6
<strong>解释:</strong>选择索引 (1, 2, 2) ,然后 A 变为 [3,1,0,2]。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>A = [2,-3,-1,5,-4], K = 2
<strong>输出:</strong>13
<strong>解释:</strong>选择索引 (1, 4) ,然后 A 变为 [2,3,-1,5,4]。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= A.length &lt;= 10000</code></li>
<li><code>1 &lt;= K &lt;= 10000</code></li>
<li><code>-100 &lt;= A[i] &lt;= 100</code></li>
</ol>
<p>通常,正整数 <code>n</code> 的阶乘是所有小于或等于 <code>n</code> 的正整数的乘积。例如,<code>factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1</code></p>
<p>相反,我们设计了一个笨阶乘 <code>clumsy</code>:在整数的递减序列中,我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符:乘法(*),除法(/),加法(+)和减法(-)。</p>
<p>例如,<code>clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1</code>。然而,这些运算仍然使用通常的算术运算顺序:我们在任何加、减步骤之前执行所有的乘法和除法步骤,并且按从左到右处理乘法和除法步骤。</p>
<p>另外,我们使用的除法是地板除法(<em>floor division</em>),所以&nbsp;<code>10 * 9 / 8</code>&nbsp;等于&nbsp;<code>11</code>。这保证结果是一个整数。</p>
<p>实现上面定义的笨函数:给定一个整数 <code>N</code>,它返回 <code>N</code> 的笨阶乘。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>4
<strong>输出:</strong>7
<strong>解释:</strong>7 = 4 * 3 / 2 + 1
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>10
<strong>输出:</strong>12
<strong>解释:</strong>12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= N &lt;= 10000</code></li>
<li><code>-2^31 &lt;= answer &lt;= 2^31 - 1</code>&nbsp; (答案保证符合 32 位整数。)</li>
</ol>
<p>在一排多米诺骨牌中,<code>A[i]</code><code>B[i]</code>&nbsp;分别代表第 i 个多米诺骨牌的上半部分和下半部分。(一个多米诺是两个从 1 到 6 的数字同列平铺形成的&nbsp;&mdash;&mdash; 该平铺的每一半上都有一个数字。)</p>
<p>我们可以旋转第&nbsp;<code>i</code>&nbsp;张多米诺,使得&nbsp;<code>A[i]</code>&nbsp;<code>B[i]</code>&nbsp;的值交换。</p>
<p>返回能使 <code>A</code> 中所有值或者 <code>B</code> 中所有值都相同的最小旋转次数。</p>
<p>如果无法做到,返回&nbsp;<code>-1</code>.</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/03/08/domino.png" style="height: 161px; width: 200px;"></p>
<pre><strong>输入:</strong>A = [2,1,2,4,2,2], B = [5,2,6,2,3,2]
<strong>输出:</strong>2
<strong>解释:</strong>
图一表示:在我们旋转之前, A 和 B 给出的多米诺牌。
如果我们旋转第二个和第四个多米诺骨牌,我们可以使上面一行中的每个值都等于 2,如图二所示。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>A = [3,5,1,2,3], B = [3,6,3,3,4]
<strong>输出:</strong>-1
<strong>解释:</strong>
在这种情况下,不可能旋转多米诺牌使一行的值相等。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= A[i], B[i] &lt;= 6</code></li>
<li><code>2 &lt;= A.length == B.length &lt;= 20000</code></li>
</ol>
<p>返回与给定前序遍历&nbsp;<code>preorder</code> 相匹配的二叉搜索树(binary <strong>search</strong> tree)的根结点。</p>
<p><em>(回想一下,二叉搜索树是二叉树的一种,其每个节点都满足以下规则,对于&nbsp;<code>node.left</code>&nbsp;的任何后代,值总 <code>&lt; node.val</code>,而 <code>node.right</code> 的任何后代,值总 <code>&gt; node.val</code>。此外,前序遍历首先显示节点&nbsp;<code>node</code> 的值,然后遍历 <code>node.left</code>,接着遍历 <code>node.right</code>。)</em></p>
<p>题目保证,对于给定的测试用例,总能找到满足要求的二叉搜索树。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>[8,5,1,7,10,12]
<strong>输出:</strong>[8,5,10,1,7,null,12]
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/03/08/1266.png" style="height: 200px; width: 306px;">
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= preorder.length &lt;= 100</code></li>
<li><code>1 &lt;= preorder[i]&nbsp;&lt;= 10^8</code></li>
<li><code>preorder</code> 中的值互不相同</li>
</ul>
<p>每个非负整数&nbsp;<code>N</code>&nbsp;都有其二进制表示。例如,&nbsp;<code>5</code>&nbsp;可以被表示为二进制&nbsp;<code>&quot;101&quot;</code><code>11</code> 可以用二进制&nbsp;<code>&quot;1011&quot;</code>&nbsp;表示,依此类推。注意,除&nbsp;<code>N = 0</code>&nbsp;外,任何二进制表示中都不含前导零。</p>
<p>二进制的反码表示是将每个&nbsp;<code>1</code>&nbsp;改为&nbsp;<code>0</code>&nbsp;且每个&nbsp;<code>0</code>&nbsp;变为&nbsp;<code>1</code>。例如,二进制数&nbsp;<code>&quot;101&quot;</code>&nbsp;的二进制反码为&nbsp;<code>&quot;010&quot;</code></p>
<p>给你一个十进制数&nbsp;<code>N</code>,请你返回其二进制表示的反码所对应的十进制整数。</p>
<p>&nbsp;</p>
<ol>
</ol>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>5
<strong>输出:</strong>2
<strong>解释:</strong>5 的二进制表示为 &quot;101&quot;,其二进制反码为 &quot;010&quot;,也就是十进制中的 2 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>7
<strong>输出:</strong>0
<strong>解释:</strong>7 的二进制表示为 &quot;111&quot;,其二进制反码为 &quot;000&quot;,也就是十进制中的 0 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>10
<strong>输出:</strong>5
<strong>解释:</strong>10 的二进制表示为 &quot;1010&quot;,其二进制反码为 &quot;0101&quot;,也就是十进制中的 5 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>0 &lt;= N &lt; 10^9</code></li>
<li>本题与 476:<a href="https://leetcode-cn.com/problems/number-complement/">https://leetcode-cn.com/problems/number-complement/</a> 相同</li>
</ol>
<p>在歌曲列表中,第 <code>i</code> 首歌曲的持续时间为 <code>time[i]</code> 秒。</p>
<p>返回其总持续时间(以秒为单位)可被 <code>60</code> 整除的歌曲对的数量。形式上,我们希望索引的数字 <code>i</code><code>j</code> 满足&nbsp; <code>i &lt; j</code> 且有&nbsp;<code>(time[i] + time[j]) % 60 == 0</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[30,20,150,100,40]
<strong>输出:</strong>3
<strong>解释:</strong>这三对的总持续时间可被 60 整数:
(time[0] = 30, time[2] = 150): 总持续时间 180
(time[1] = 20, time[3] = 100): 总持续时间 120
(time[1] = 20, time[4] = 40): 总持续时间 60
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[60,60,60]
<strong>输出:</strong>3
<strong>解释:</strong>所有三对的总持续时间都是 120,可以被 60 整数。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= time.length &lt;= 60000</code></li>
<li><code>1 &lt;= time[i] &lt;= 500</code></li>
</ol>
<p>给定一个二叉树,检查它是否是镜像对称的。</p>
<p>&nbsp;</p>
<p>例如,二叉树&nbsp;<code>[1,2,2,3,4,4,3]</code> 是对称的。</p>
<pre> 1
/ \
2 2
/ \ / \
3 4 4 3
</pre>
<p>&nbsp;</p>
<p>但是下面这个&nbsp;<code>[1,2,2,null,3,null,3]</code> 则不是镜像对称的:</p>
<pre> 1
/ \
2 2
\ \
3 3
</pre>
<p>&nbsp;</p>
<p><strong>进阶:</strong></p>
<p>你可以运用递归和迭代两种方法解决这个问题吗?</p>
<p>传送带上的包裹必须在 D 天内从一个港口运送到另一个港口。</p>
<p>传送带上的第 <code>i</code> 个包裹的重量为 <code>weights[i]</code>。每一天,我们都会按给出重量的顺序往传送带上装载包裹。我们装载的重量不会超过船的最大运载重量。</p>
<p>返回能在 <code>D</code> 天内将传送带上的所有包裹送达的船的最低运载能力。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>weights = [1,2,3,4,5,6,7,8,9,10], D = 5
<strong>输出:</strong>15
<strong>解释:</strong>
船舶最低载重 15 就能够在 5 天内送达所有包裹,如下所示:
第 1 天:1, 2, 3, 4, 5
第 2 天:6, 7
第 3 天:8
第 4 天:9
第 5 天:10
请注意,货物必须按照给定的顺序装运,因此使用载重能力为 14 的船舶并将包装分成 (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) 是不允许的。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>weights = [3,2,2,4,1,4], D = 3
<strong>输出:</strong>6
<strong>解释:</strong>
船舶最低载重 6 就能够在 3 天内送达所有包裹,如下所示:
第 1 天:3, 2
第 2 天:2, 4
第 3 天:1, 4
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>weights = [1,2,3,1,1], D = 4
<strong>输出:</strong>3
<strong>解释:</strong>
第 1 天:1
第 2 天:2
第 3 天:3
第 4 天:1, 1
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= D <= weights.length <= 5 * 10<sup>4</sup></code></li>
<li><code>1 <= weights[i] <= 500</code></li>
</ul>
<p>给定正整数&nbsp;<code>N</code>,返回小于等于 <code>N</code>&nbsp;且具有至少 1 位重复数字的正整数的个数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>20
<strong>输出:</strong>1
<strong>解释:</strong>具有至少 1 位重复数字的正数(&lt;= 20)只有 11 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>100
<strong>输出:</strong>10
<strong>解释:</strong>具有至少 1 位重复数字的正数(&lt;= 100)有 11,22,33,44,55,66,77,88,99 和 100 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>1000
<strong>输出:</strong>262
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= N &lt;= 10^9</code></li>
</ol>
<p>给你一个整数数组 <code>arr</code>,只有可以将其划分为三个和相等的 <strong>非空</strong> 部分时才返回 <code>true</code>,否则返回 <code>false</code></p>
<p>形式上,如果可以找出索引 <code>i + 1 < j</code> 且满足 <code>(arr[0] + arr[1] + ... + arr[i] == arr[i + 1] + arr[i + 2] + ... + arr[j - 1] == arr[j] + arr[j + 1] + ... + arr[arr.length - 1])</code> 就可以将数组三等分。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>arr = [0,2,1,-6,6,-7,9,1,2,0,1]
<strong>输出:</strong>true
<strong>解释:</strong>0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>arr = [0,2,1,-6,6,7,9,-1,2,0,1]
<strong>输出:</strong>false
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>arr = [3,3,6,5,-2,2,5,1,-9,4]
<strong>输出:</strong>true
<strong>解释:</strong>3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 <= arr.length <= 5 * 10<sup>4</sup></code></li>
<li><code>-10<sup>4</sup> <= arr[i] <= 10<sup>4</sup></code></li>
</ul>
<p>给你一个正整数数组 <code>values</code>,其中 <code>values[i]</code> 表示第 <code>i</code> 个观光景点的评分,并且两个景点 <code>i</code> 和 <code>j</code> 之间的 <strong>距离</strong> 为 <code>j - i</code></p>
<p>一对景点(<code>i < j</code>)组成的观光组合的得分为 <code>values[i] + values[j] + i - j</code> ,也就是景点的评分之和<strong> 减去 </strong>它们两者之间的距离。</p>
<p>返回一对观光景点能取得的最高分。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>values = [8,1,5,2,6]
<strong>输出:</strong>11
<strong>解释:</strong>i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>values = [1,2]
<strong>输出:</strong>2
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 <= values.length <= 5 * 10<sup>4</sup></code></li>
<li><code>1 <= values[i] <= 1000</code></li>
</ul>
<p>给定正整数&nbsp;<code>K</code>,你需要找出可以被 K 整除的、仅包含数字 <strong>1</strong> 的最小正整数 N。</p>
<p>返回&nbsp;<code>N</code>&nbsp;的长度。如果不存在这样的&nbsp;<code>N</code>,就返回 <code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>1
<strong>输出:</strong>1
<strong>解释:</strong>最小的答案是 N = 1,其长度为 1。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>2
<strong>输出:</strong>-1
<strong>解释:</strong>不存在可被 2 整除的正整数 N 。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>3
<strong>输出:</strong>3
<strong>解释:</strong>最小的答案是 N = 111,其长度为 3。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= K &lt;= 10^5</code></li>
</ul>
<p>给定一个二进制字符串&nbsp;<code>S</code>(一个仅由若干&nbsp;&#39;0&#39;&#39;1&#39; 构成的字符串)和一个正整数&nbsp;<code>N</code>,如果对于从 <code>1</code><code>N</code> 的每个整数 <code>X</code>,其二进制表示都是&nbsp;<code>S</code> 的子串,就返回 <code>true</code>,否则返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>S = &quot;0110&quot;, N = 3
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>S = &quot;0110&quot;, N = 4
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= S.length &lt;= 1000</code></li>
<li><code>1 &lt;= N &lt;= 10^9</code></li>
</ol>
<p>给出数字&nbsp;<code>N</code>,返回由若干&nbsp;<code>&quot;0&quot;</code>&nbsp;&nbsp;<code>&quot;1&quot;</code>组成的字符串,该字符串为 <code>N</code>&nbsp;<strong>负二进制(<code>base -2</code></strong>表示。</p>
<p>除非字符串就是&nbsp;<code>&quot;0&quot;</code>,否则返回的字符串中不能含有前导零。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>2
<strong>输出:</strong>&quot;110&quot;
<strong>解释:</strong>(-2) ^ 2 + (-2) ^ 1 = 2
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>3
<strong>输出:</strong>&quot;111&quot;
<strong>解释:</strong>(-2) ^ 2 + (-2) ^ 1 + (-2) ^ 0 = 3
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>4
<strong>输出:</strong>&quot;100&quot;
<strong>解释:</strong>(-2) ^ 2 = 4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>0 &lt;= N &lt;= 10^9</code></li>
</ol>
<p>给定由若干&nbsp;<code>0</code>&nbsp;&nbsp;<code>1</code>&nbsp;组成的数组 <code>A</code>。我们定义&nbsp;<code>N_i</code>:从&nbsp;<code>A[0]</code>&nbsp;<code>A[i]</code>&nbsp;的第 <code>i</code>&nbsp;个子数组被解释为一个二进制数(从最高有效位到最低有效位)。</p>
<p>返回布尔值列表&nbsp;<code>answer</code>,只有当&nbsp;<code>N_i</code>&nbsp;可以被 <code>5</code>&nbsp;整除时,答案&nbsp;<code>answer[i]</code>&nbsp;<code>true</code>,否则为 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[0,1,1]
<strong>输出:</strong>[true,false,false]
<strong>解释:</strong>
输入数字为 0, 01, 011;也就是十进制中的 0, 1, 3 。只有第一个数可以被 5 整除,因此 answer[0] 为真。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[1,1,1]
<strong>输出:</strong>[false,false,false]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>[0,1,1,1,1,1]
<strong>输出:</strong>[true,false,false,false,true,false]
</pre>
<p><strong>示例&nbsp;4:</strong></p>
<pre><strong>输入:</strong>[1,1,1,0,1]
<strong>输出:</strong>[false,false,false,false,false]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= A.length &lt;= 30000</code></li>
<li><code>A[i]</code>&nbsp;<code>0</code>&nbsp;&nbsp;<code>1</code></li>
</ol>
<p>给出一个以头节点&nbsp;<code>head</code>&nbsp;作为第一个节点的链表。链表中的节点分别编号为:<code>node_1, node_2, node_3, ...</code></p>
<p>每个节点都可能有下一个更大值(<em>next larger</em> <strong>value</strong>):对于&nbsp;<code>node_i</code>,如果其&nbsp;<code>next_larger(node_i)</code>&nbsp;&nbsp;<code>node_j.val</code>,那么就有&nbsp;<code>j &gt; i</code>&nbsp;&nbsp;&nbsp;<code>node_j.val &gt; node_i.val</code>,而&nbsp;<code>j</code>&nbsp;是可能的选项中最小的那个。如果不存在这样的&nbsp;<code>j</code>,那么下一个更大值为&nbsp;<code>0</code>&nbsp;</p>
<p>返回整数答案数组&nbsp;<code>answer</code>,其中&nbsp;<code>answer[i] = next_larger(node_{i+1})</code>&nbsp;</p>
<p><strong><em>注意:</em></strong>在下面的示例中,诸如 <code>[2,1,5]</code> 这样的<strong>输入</strong>(不是输出)是链表的序列化表示,其头节点的值为&nbsp;2,第二个节点值为 1,第三个节点值为&nbsp;5 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[2,1,5]
<strong>输出:</strong>[5,5,0]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[2,7,4,3,5]
<strong>输出:</strong>[7,0,5,5,0]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>[1,7,5,1,9,2,5,1]
<strong>输出:</strong>[7,9,9,9,0,5,0,0]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li>对于链表中的每个节点,<code>1 &lt;= node.val&nbsp;&lt;= 10^9</code></li>
<li>给定列表的长度在 <code>[0, 10000]</code>&nbsp;范围内</li>
</ol>
<p>给出一个二维数组&nbsp;<code>A</code>,每个单元格为 0(代表海)或 1(代表陆地)。</p>
<p>移动是指在陆地上从一个地方走到另一个地方(朝四个方向之一)或离开网格的边界。</p>
<p>返回网格中<strong>无法</strong>在任意次数的移动中离开网格边界的陆地单元格的数量。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
<strong>输出:</strong>3
<strong>解释: </strong>
有三个 1 被 0 包围。一个 1 没有被包围,因为它在边界上。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
<strong>输出:</strong>0
<strong>解释:</strong>
所有 1 都在边界上或可以到达边界。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= A.length &lt;= 500</code></li>
<li><code>1 &lt;= A[i].length &lt;= 500</code></li>
<li><code>0 &lt;= A[i][j] &lt;= 1</code></li>
<li>所有行的大小都相同</li>
</ol>
<p>给你一个二叉树,请你返回其按 <strong>层序遍历</strong> 得到的节点值。 (即逐层地,从左到右访问所有节点)。</p>
<p> </p>
<p><strong>示例:</strong><br />
二叉树:<code>[3,9,20,null,null,15,7]</code>,</p>
<pre>
3
/ \
9 20
/ \
15 7
</pre>
<p>返回其层序遍历结果:</p>
<pre>
[
[3],
[9,20],
[15,7]
]
</pre>
<p>有效括号字符串为空 <code>""</code><code>"(" + A + ")"</code> 或 <code>A + B</code> ,其中 <code>A</code> 和 <code>B</code> 都是有效的括号字符串,<code>+</code> 代表字符串的连接。</p>
<ul>
<li>例如,<code>""</code><code>"()"</code><code>"(())()"</code> 和 <code>"(()(()))"</code> 都是有效的括号字符串。</li>
</ul>
<p>如果有效字符串 <code>s</code> 非空,且不存在将其拆分为 <code>s = A + B</code> 的方法,我们称其为<strong>原语(primitive)</strong>,其中 <code>A</code> 和 <code>B</code> 都是非空有效括号字符串。</p>
<p>给出一个非空有效字符串 <code>s</code>,考虑将其进行原语化分解,使得:<code>s = P_1 + P_2 + ... + P_k</code>,其中 <code>P_i</code> 是有效括号字符串原语。</p>
<p><code>s</code> 进行原语化分解,删除分解中每个原语字符串的最外层括号,返回 <code>s</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "(()())(())"
<strong>输出:</strong>"()()()"
<strong>解释:
</strong>输入字符串为 "(()())(())",原语化分解得到 "(()())" + "(())",
删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "(()())(())(()(()))"
<strong>输出:</strong>"()()()()(())"
<strong>解释:</strong>
输入字符串为 "(()())(())(()(()))",原语化分解得到 "(()())" + "(())" + "(()(()))",
删除每个部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "()()"
<strong>输出:</strong>""
<strong>解释:</strong>
输入字符串为 "()()",原语化分解得到 "()" + "()",
删除每个部分中的最外层括号后得到 "" + "" = ""。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
<li><code>s[i]</code><code>'('</code><code>')'</code></li>
<li><code>s</code> 是一个有效括号字符串</li>
</ul>
<p>给出一棵二叉树,其上每个结点的值都是 <code>0</code> 或 <code>1</code> 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。例如,如果路径为 <code>0 -> 1 -> 1 -> 0 -> 1</code>,那么它表示二进制数 <code>01101</code>,也就是 <code>13</code> 。</p>
<p>对树上的每一片叶子,我们都要找出从根到该叶子的路径所表示的数字。</p>
<p>返回这些数字之和。题目数据保证答案是一个 <strong>32 位 </strong>整数。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2019/04/04/sum-of-root-to-leaf-binary-numbers.png" style="width: 450px; height: 296px;" />
<pre>
<strong>输入:</strong>root = [1,0,1,0,1,0,1]
<strong>输出:</strong>22
<strong>解释:</strong>(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = [0]
<strong>输出:</strong>0
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [1]
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>root = [1,1]
<strong>输出:</strong>3
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的结点数介于 <code>1</code><code>1000</code> 之间。</li>
<li><code>Node.val</code><code>0</code><code>1</code></li>
</ul>
<p>如果我们可以将<strong>小写字母</strong>插入模式串&nbsp;<code>pattern</code>&nbsp;得到待查询项&nbsp;<code>query</code>,那么待查询项与给定模式串匹配。(我们可以在任何位置插入每个字符,也可以插入 0 个字符。)</p>
<p>给定待查询列表&nbsp;<code>queries</code>,和模式串&nbsp;<code>pattern</code>,返回由布尔值组成的答案列表&nbsp;<code>answer</code>。只有在待查项&nbsp;<code>queries[i]</code> 与模式串&nbsp;<code>pattern</code> 匹配时,&nbsp;<code>answer[i]</code>&nbsp;才为 <code>true</code>,否则为 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>queries = [&quot;FooBar&quot;,&quot;FooBarTest&quot;,&quot;FootBall&quot;,&quot;FrameBuffer&quot;,&quot;ForceFeedBack&quot;], pattern = &quot;FB&quot;
<strong>输出:</strong>[true,false,true,true,false]
<strong>示例:</strong>
&quot;FooBar&quot; 可以这样生成:&quot;F&quot; + &quot;oo&quot; + &quot;B&quot; + &quot;ar&quot;
&quot;FootBall&quot; 可以这样生成:&quot;F&quot; + &quot;oot&quot; + &quot;B&quot; + &quot;all&quot;.
&quot;FrameBuffer&quot; 可以这样生成:&quot;F&quot; + &quot;rame&quot; + &quot;B&quot; + &quot;uffer&quot;.</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>queries = [&quot;FooBar&quot;,&quot;FooBarTest&quot;,&quot;FootBall&quot;,&quot;FrameBuffer&quot;,&quot;ForceFeedBack&quot;], pattern = &quot;FoBa&quot;
<strong>输出:</strong>[true,false,true,false,false]
<strong>解释:</strong>
&quot;FooBar&quot; 可以这样生成:&quot;Fo&quot; + &quot;o&quot; + &quot;Ba&quot; + &quot;r&quot;.
&quot;FootBall&quot; 可以这样生成:&quot;Fo&quot; + &quot;ot&quot; + &quot;Ba&quot; + &quot;ll&quot;.
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输出:</strong>queries = [&quot;FooBar&quot;,&quot;FooBarTest&quot;,&quot;FootBall&quot;,&quot;FrameBuffer&quot;,&quot;ForceFeedBack&quot;], pattern = &quot;FoBaT&quot;
<strong>输入:</strong>[false,true,false,false,false]
<strong>解释: </strong>
&quot;FooBarTest&quot; 可以这样生成:&quot;Fo&quot; + &quot;o&quot; + &quot;Ba&quot; + &quot;r&quot; + &quot;T&quot; + &quot;est&quot;.
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= queries.length &lt;= 100</code></li>
<li><code>1 &lt;= queries[i].length &lt;= 100</code></li>
<li><code>1 &lt;= pattern.length &lt;= 100</code></li>
<li>所有字符串都仅由大写和小写英文字母组成。</li>
</ol>
<p>你将会获得一系列视频片段,这些片段来自于一项持续时长为 <code>T</code> 秒的体育赛事。这些片段可能有所重叠,也可能长度不一。</p>
<p>视频片段 <code>clips[i]</code> 都用区间进行表示:开始于 <code>clips[i][0]</code> 并于 <code>clips[i][1]</code> 结束。我们甚至可以对这些片段自由地再剪辑,例如片段 <code>[0, 7]</code> 可以剪切成 <code>[0, 1] + [1, 3] + [3, 7]</code> 三部分。</p>
<p>我们需要将这些片段进行再剪辑,并将剪辑后的内容拼接成覆盖整个运动过程的片段(<code>[0, T]</code>)。返回所需片段的最小数目,如果无法完成该任务,则返回 <code>-1</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], T = 10
<strong>输出:</strong>3
<strong>解释:</strong>
我们选中 [0,2], [8,10], [1,9] 这三个片段。
然后,按下面的方案重制比赛片段:
将 [1,9] 再剪辑为 [1,2] + [2,8] + [8,9] 。
现在我们手上有 [0,2] + [2,8] + [8,10],而这些涵盖了整场比赛 [0, 10]。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>clips = [[0,1],[1,2]], T = 5
<strong>输出:</strong>-1
<strong>解释:</strong>
我们无法只用 [0,1] 和 [1,2] 覆盖 [0,5] 的整个过程。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,5],[5,7],[6,9]], T = 9
<strong>输出:</strong>3
<strong>解释: </strong>
我们选取片段 [0,4], [4,7] 和 [6,9] 。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>clips = [[0,4],[2,8]], T = 5
<strong>输出:</strong>2
<strong>解释:</strong>
注意,你可能录制超过比赛结束时间的视频。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= clips.length <= 100</code></li>
<li><code>0 <= clips[i][0] <= clips[i][1] <= 100</code></li>
<li><code>0 <= T <= 100</code></li>
</ul>
<p>爱丽丝和鲍勃一起玩游戏,他们轮流行动。爱丽丝先手开局。</p>
<p>最初,黑板上有一个数字&nbsp;<code>N</code>&nbsp;。在每个玩家的回合,玩家需要执行以下操作:</p>
<ul>
<li>选出任一&nbsp;<code>x</code>,满足&nbsp;<code>0 &lt; x &lt; N</code>&nbsp;<code>N % x == 0</code>&nbsp;</li>
<li><code>N - x</code>&nbsp;替换黑板上的数字 <code>N</code></li>
</ul>
<p>如果玩家无法执行这些操作,就会输掉游戏。</p>
<p>只有在爱丽丝在游戏中取得胜利时才返回&nbsp;<code>True</code>,否则返回 <code>False</code>。假设两个玩家都以最佳状态参与游戏。</p>
<p>&nbsp;</p>
<ol>
</ol>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>2
<strong>输出:</strong>true
<strong>解释:</strong>爱丽丝选择 1,鲍勃无法进行操作。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>3
<strong>输出:</strong>false
<strong>解释:</strong>爱丽丝选择 1,鲍勃也选择 1,然后爱丽丝无法进行操作。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= N &lt;= 1000</code></li>
</ol>
<p>给定二叉树的根节点 <code>root</code>,找出存在于 <strong>不同</strong> 节点 <code>A</code> 和 <code>B</code> 之间的最大值 <code>V</code>,其中 <code>V = |A.val - B.val|</code>,且 <code>A</code> 是 <code>B</code> 的祖先。</p>
<p>(如果 A 的任何子节点之一为 B,或者 A 的任何子节点是 B 的祖先,那么我们认为 A 是 B 的祖先)</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg" style="width: 400px; height: 390px;" /></p>
<pre>
<strong>输入:</strong>root = [8,3,10,1,6,null,14,null,null,4,7,13]
<strong>输出:</strong>7
<strong>解释: </strong>
我们有大量的节点与其祖先的差值,其中一些如下:
|8 - 3| = 5
|3 - 7| = 4
|8 - 1| = 7
|10 - 13| = 3
在所有可能的差值中,最大值 7 由 |8 - 1| = 7 得出。
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg" style="width: 250px; height: 349px;" />
<pre>
<strong>输入:</strong>root = [1,null,2,null,0,3]
<strong>输出:</strong>3
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的节点数在 <code>2</code> 到 <code>5000</code> 之间。</li>
<li><code>0 <= Node.val <= 10<sup>5</sup></code></li>
</ul>
<p>给定一个整数数组&nbsp;<code>A</code>,返回 <code>A</code>&nbsp;中最长等差子序列的<strong>长度</strong></p>
<p>回想一下,<code>A</code>&nbsp;的子序列是列表&nbsp;<code>A[i_1], A[i_2], ..., A[i_k]</code> 其中&nbsp;<code>0 &lt;= i_1 &lt; i_2 &lt; ... &lt; i_k &lt;= A.length - 1</code>。并且如果&nbsp;<code>B[i+1] - B[i]</code>(&nbsp;<code>0 &lt;= i &lt; B.length - 1</code>) 的值都相同,那么序列&nbsp;<code>B</code>&nbsp;是等差的。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[3,6,9,12]
<strong>输出:</strong>4
<strong>解释: </strong>
整个数组是公差为 3 的等差数列。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[9,4,7,2,10]
<strong>输出:</strong>3
<strong>解释:</strong>
最长的等差子序列是 [4,7,10]。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>[20,1,15,3,10,5,8]
<strong>输出:</strong>4
<strong>解释:</strong>
最长的等差子序列是 [20,15,10,5]。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>2 &lt;= A.length &lt;= 2000</code></li>
<li><code>0 &lt;= A[i] &lt;= 10000</code></li>
</ol>
<p>我们从二叉树的根节点 <code>root</code>&nbsp;开始进行深度优先搜索。</p>
<p>在遍历中的每个节点处,我们输出&nbsp;<code>D</code>&nbsp;条短划线(其中&nbsp;<code>D</code>&nbsp;是该节点的深度),然后输出该节点的值。(<em>如果节点的深度为 <code>D</code>,则其直接子节点的深度为 <code>D + 1</code>。根节点的深度为 <code>0</code>)。</em></p>
<p>如果节点只有一个子节点,那么保证该子节点为左子节点。</p>
<p>给出遍历输出&nbsp;<code>S</code>,还原树并返回其根节点&nbsp;<code>root</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/recover-a-tree-from-preorder-traversal.png" style="height: 200px; width: 320px;"></strong></p>
<pre><strong>输入:</strong>&quot;1-2--3--4-5--6--7&quot;
<strong>输出:</strong>[1,2,5,3,4,6,7]
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114101-pm.png" style="height: 250px; width: 256px;"></strong></p>
<pre><strong>输入:</strong>&quot;1-2--3---4-5--6---7&quot;
<strong>输出:</strong>[1,2,5,3,null,6,null,4,null,7]
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/12/screen-shot-2019-04-10-at-114955-pm.png" style="height: 250px; width: 276px;"></p>
<pre><strong>输入:</strong>&quot;1-401--349---90--88&quot;
<strong>输出:</strong>[1,401,null,349,88,90]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>原始树中的节点数介于 <code>1</code><code>1000</code> 之间。</li>
<li>每个节点的值介于 <code>1</code><code>10 ^ 9</code> 之间。</li>
</ul>
<p>公司计划面试 <code>2n</code> 人。给你一个数组 <code>costs</code> ,其中 <code>costs[i] = [aCost<sub>i</sub>, bCost<sub>i</sub>]</code> 。第 <code>i</code> 人飞往 <code>a</code> 市的费用为 <code>aCost<sub>i</sub></code> ,飞往 <code>b</code> 市的费用为 <code>bCost<sub>i</sub></code></p>
<p>返回将每个人都飞到 <code>a</code><code>b</code> 中某座城市的最低费用,要求每个城市都有 <code>n</code> 人抵达<strong></strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>costs = [[10,20],[30,200],[400,50],[30,20]]
<strong>输出:</strong>110
<strong>解释:</strong>
第一个人去 a 市,费用为 10。
第二个人去 a 市,费用为 30。
第三个人去 b 市,费用为 50。
第四个人去 b 市,费用为 20。
最低总费用为 10 + 30 + 50 + 20 = 110,每个城市都有一半的人在面试。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]
<strong>输出:</strong>1859
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]]
<strong>输出:</strong>3086
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 * n == costs.length</code></li>
<li><code>2 <= costs.length <= 100</code></li>
<li><code>costs.length</code> 为偶数</li>
<li><code>1 <= aCost<sub>i</sub>, bCost<sub>i</sub> <= 1000</code></li>
</ul>
<p>给出 <code>R</code><code>C</code> 列的矩阵,其中的单元格的整数坐标为 <code>(r, c)</code>,满足 <code>0 &lt;= r &lt; R</code><code>0 &lt;= c &lt; C</code></p>
<p>另外,我们在该矩阵中给出了一个坐标为&nbsp;<code>(r0, c0)</code> 的单元格。</p>
<p>返回矩阵中的所有单元格的坐标,并按到 <code>(r0, c0)</code> 的距离从最小到最大的顺序排,其中,两单元格<code>(r1, c1)</code><code>(r2, c2)</code> 之间的距离是曼哈顿距离,<code>|r1 - r2| + |c1 - c2|</code>。(你可以按任何满足此条件的顺序返回答案。)</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>R = 1, C = 2, r0 = 0, c0 = 0
<strong>输出:</strong>[[0,0],[0,1]]
<strong>解释</strong>:从 (r0, c0) 到其他单元格的距离为:[0,1]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>R = 2, C = 2, r0 = 0, c0 = 1
<strong>输出:</strong>[[0,1],[0,0],[1,1],[1,0]]
<strong>解释</strong>:从 (r0, c0) 到其他单元格的距离为:[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>R = 2, C = 3, r0 = 1, c0 = 2
<strong>输出:</strong>[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
<strong>解释</strong>:从 (r0, c0) 到其他单元格的距离为:[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确,例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= R &lt;= 100</code></li>
<li><code>1 &lt;= C &lt;= 100</code></li>
<li><code>0 &lt;= r0 &lt; R</code></li>
<li><code>0 &lt;= c0 &lt; C</code></li>
</ol>
<p>给定一个二叉树,返回其节点值的锯齿形层序遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。</p>
<p>例如:<br />
给定二叉树 <code>[3,9,20,null,null,15,7]</code>,</p>
<pre>
3
/ \
9 20
/ \
15 7
</pre>
<p>返回锯齿形层序遍历如下:</p>
<pre>
[
[3],
[20,9],
[15,7]
]
</pre>
<p>给出非负整数数组 <code>A</code> ,返回两个非重叠(连续)子数组中元素的最大和,子数组的长度分别为 <code>L</code><code>M</code>。(这里需要澄清的是,长为 L 的子数组可以出现在长为 M 的子数组之前或之后。)</p>
<p>从形式上看,返回最大的 <code>V</code>,而 <code>V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1])</code> 并满足下列条件之一:</p>
<p>&nbsp;</p>
<ul>
<li><code>0 &lt;= i &lt; i + L - 1 &lt; j &lt; j + M - 1 &lt; A.length</code>, <strong></strong></li>
<li><code>0 &lt;= j &lt; j + M - 1 &lt; i &lt; i + L - 1 &lt; A.length</code>.</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
<strong>输出:</strong>20
<strong>解释:</strong>子数组的一种选择中,[9] 长度为 1,[6,5] 长度为 2。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2
<strong>输出:</strong>29
<strong>解释:</strong>子数组的一种选择中,[3,8,1] 长度为 3,[8,9] 长度为 2。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3
<strong>输出:</strong>31
<strong>解释:</strong>子数组的一种选择中,[5,6,0,9] 长度为 4,[0,3,8] 长度为 3。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>L &gt;= 1</code></li>
<li><code>M &gt;= 1</code></li>
<li><code>L + M &lt;= A.length &lt;= 1000</code></li>
<li><code>0 &lt;= A[i] &lt;= 1000</code></li>
</ol>
<p>按下述要求实现 <code>StreamChecker</code> 类:</p>
<ul>
<li><code>StreamChecker(words)</code>:构造函数,用给定的字词初始化数据结构。</li>
<li><code>query(letter)</code>:如果存在某些 <code>k &gt;= 1</code>,可以用查询的最后 <code>k</code>个字符(按从旧到新顺序,包括刚刚查询的字母)拼写出给定字词表中的某一字词时,返回 <code>true</code>。否则,返回 <code>false</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre>StreamChecker streamChecker = new StreamChecker([&quot;cd&quot;,&quot;f&quot;,&quot;kl&quot;]); // 初始化字典
streamChecker.query(&#39;a&#39;); // 返回 false
streamChecker.query(&#39;b&#39;); // 返回 false
streamChecker.query(&#39;c&#39;); // 返回 false
streamChecker.query(&#39;d&#39;); // 返回 true,因为 &#39;cd&#39; 在字词表中
streamChecker.query(&#39;e&#39;); // 返回 false
streamChecker.query(&#39;f&#39;); // 返回 true,因为 &#39;f&#39; 在字词表中
streamChecker.query(&#39;g&#39;); // 返回 false
streamChecker.query(&#39;h&#39;); // 返回 false
streamChecker.query(&#39;i&#39;); // 返回 false
streamChecker.query(&#39;j&#39;); // 返回 false
streamChecker.query(&#39;k&#39;); // 返回 false
streamChecker.query(&#39;l&#39;); // 返回 true,因为 &#39;kl&#39; 在字词表中。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= words.length &lt;= 2000</code></li>
<li><code>1 &lt;= words[i].length &lt;= 2000</code></li>
<li>字词只包含小写英文字母。</li>
<li>待查项只包含小写英文字母。</li>
<li>待查项最多 40000 个。</li>
</ul>
<p>三枚石子放置在数轴上,位置分别为 <code>a</code><code>b</code><code>c</code></p>
<p>每一回合,你可以从两端之一拿起一枚石子(位置最大或最小),并将其放入两端之间的任一空闲位置。形式上,假设这三枚石子当前分别位于位置 <code>x, y, z</code><code>x < y < z</code>。那么就可以从位置 <code>x</code> 或者是位置 <code>z</code> 拿起一枚石子,并将该石子移动到某一整数位置 <code>k</code> 处,其中 <code>x < k < z</code><code>k != y</code></p>
<p>当你无法进行任何移动时,即,这些石子的位置连续时,游戏结束。</p>
<p>要使游戏结束,你可以执行的最小和最大移动次数分别是多少? 以长度为 2 的数组形式返回答案:<code>answer = [minimum_moves, maximum_moves]</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>a = 1, b = 2, c = 5
<strong>输出:</strong>[1, 2]
<strong>解释:</strong>将石子从 5 移动到 4 再移动到 3,或者我们可以直接将石子移动到 3。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>a = 4, b = 3, c = 2
<strong>输出:</strong>[0, 0]
<strong>解释:</strong>我们无法进行任何移动。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 <= a <= 100</code></li>
<li><code>1 <= b <= 100</code></li>
<li><code>1 <= c <= 100</code></li>
<li><code>a != b, b != c, c != a</code></li>
</ol>
<p>给出一个二维整数网格&nbsp;<code>grid</code>,网格中的每个值表示该位置处的网格块的颜色。</p>
<p>只有当两个网格块的颜色相同,而且在四个方向中任意一个方向上相邻时,它们属于同一<strong>连通分量</strong></p>
<p>连通分量的<strong>边界</strong>是指连通分量中的所有与不在分量中的正方形相邻(四个方向上)的所有正方形,或者在网格的边界上(第一行/列或最后一行/列)的所有正方形。</p>
<p>给出位于&nbsp;<code>(r0, c0)</code>&nbsp;的网格块和颜色&nbsp;<code>color</code>,使用指定颜色&nbsp;<code>color</code>&nbsp;为所给网格块的连通分量的边界进行着色,并返回最终的网格&nbsp;<code>grid</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
<strong>输出:</strong>[[3, 3], [3, 2]]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>grid = [[1,2,2],[2,3,2]], r0 = 0, c0 = 1, color = 3
<strong>输出:</strong>[[1, 3, 3], [2, 3, 3]]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1,1],[1,1,1],[1,1,1]], r0 = 1, c0 = 1, color = 2
<strong>输出:</strong>[[2, 2, 2], [2, 1, 2], [2, 2, 2]]</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= grid.length &lt;= 50</code></li>
<li><code>1 &lt;= grid[0].length &lt;= 50</code></li>
<li><code>1 &lt;= grid[i][j] &lt;= 1000</code></li>
<li><code>0 &lt;= r0 &lt; grid.length</code></li>
<li><code>0 &lt;= c0 &lt; grid[0].length</code></li>
<li><code>1 &lt;= color &lt;= 1000</code></li>
</ol>
<p>&nbsp;</p>
<p>在两条独立的水平线上按给定的顺序写下 <code>nums1</code><code>nums2</code> 中的整数。</p>
<p>现在,可以绘制一些连接两个数字 <code>nums1[i]</code> 和 <code>nums2[j]</code> 的直线,这些直线需要同时满足满足:</p>
<ul>
<li> <code>nums1[i] == nums2[j]</code></li>
<li>且绘制的直线不与任何其他连线(非水平线)相交。</li>
</ul>
<p>请注意,连线即使在端点也不能相交:每个数字只能属于一条连线。</p>
<p>以这种方法绘制线条,并返回可以绘制的最大连线数。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/28/142.png" style="height: 72px; width: 100px;" /></strong>
<pre>
<strong>输入:</strong>nums1 = <span id="example-input-1-1">[1,4,2]</span>, nums2 = <span id="example-input-1-2">[1,2,4]</span>
<strong>输出:</strong><span id="example-output-1">2</span>
<strong>解释:</strong>可以画出两条不交叉的线,如上图所示。
但无法画出第三条不相交的直线,因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。
</pre>
<div>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums1 = <span id="example-input-2-1">[2,5,1,2,5]</span>, nums2 = <span id="example-input-2-2">[10,5,2,1,5,2]</span>
<strong>输出:</strong><span id="example-output-2">3</span>
</pre>
<div>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>nums1 = <span id="example-input-3-1">[1,3,7,1,7,5]</span>, nums2 = <span id="example-input-3-2">[1,9,2,5,1]</span>
<strong>输出:</strong><span id="example-output-3">2</span></pre>
<p> </p>
</div>
</div>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= nums1.length <= 500</code></li>
<li><code>1 <= nums2.length <= 500</code></li>
<li><code><font face="monospace">1 <= nums1[i], nums2[i] <= 2000</font></code></li>
</ul>
<p> </p>
<p>在一个 10<sup>6</sup> x 10<sup>6</sup> 的网格中,每个网格上方格的坐标为 <code>(x, y)</code></p>
<p>现在从源方格 <code>source = [s<sub>x</sub>, s<sub>y</sub>]</code> 开始出发,意图赶往目标方格 <code>target = [t<sub>x</sub>, t<sub>y</sub>]</code> 。数组 <code>blocked</code> 是封锁的方格列表,其中每个 <code>blocked[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> 表示坐标为 <code>(x<sub>i</sub>, y<sub>i</sub>)</code> 的方格是禁止通行的。</p>
<p>每次移动,都可以走到网格中在四个方向上相邻的方格,只要该方格 <strong></strong> 在给出的封锁列表 <code>blocked</code> 上。同时,不允许走出网格。</p>
<p>只有在可以通过一系列的移动从源方格 <code>source</code> 到达目标方格 <code>target</code> 时才返回 <code>true</code>。否则,返回 <code>false</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
<strong>输出:</strong>false
<strong>解释:</strong>
从源方格无法到达目标方格,因为我们无法在网格中移动。
无法向北或者向东移动是因为方格禁止通行。
无法向南或者向西移动是因为不能走出网格。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>blocked = [], source = [0,0], target = [999999,999999]
<strong>输出:</strong>true
<strong>解释:</strong>
因为没有方格被封锁,所以一定可以到达目标方格。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 <= blocked.length <= 200</code></li>
<li><code>blocked[i].length == 2</code></li>
<li><code>0 <= x<sub>i</sub>, y<sub>i</sub> < 10<sup>6</sup></code></li>
<li><code>source.length == target.length == 2</code></li>
<li><code>0 <= s<sub>x</sub>, s<sub>y</sub>, t<sub>x</sub>, t<sub>y</sub> < 10<sup>6</sup></code></li>
<li><code>source != target</code></li>
<li>题目数据保证 <code>source</code><code>target</code> 不在封锁列表内</li>
</ul>
<p>回旋镖定义为一组三个点,这些点各不相同且<strong></strong>在一条直线上。</p>
<p>给出平面上三个点组成的列表,判断这些点是否可以构成回旋镖。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[[1,1],[2,3],[3,2]]
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[[1,1],[2,2],[3,3]]
<strong>输出:</strong>false</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>points.length == 3</code></li>
<li><code>points[i].length == 2</code></li>
<li><code>0 &lt;= points[i][j] &lt;= 100</code></li>
</ol>
<p><span style="font-size:10.5pt"><span style="font-family:Calibri"><span style="font-size:10.5000pt"><span style="font-family:宋体"><font face="宋体">给定一个二叉搜索树,请将它的每个</font></span></span></span></span>节点<span style="font-size:10.5pt"><span style="font-family:Calibri"><span style="font-size:10.5000pt"><span style="font-family:宋体"><font face="宋体">的值替换成树中大于或者等于该</font></span></span></span></span>节点<span style="font-size:10.5pt"><span style="font-family:Calibri"><span style="font-size:10.5000pt"><span style="font-family:宋体"><font face="宋体">值的所有</font></span></span></span></span>节点<span style="font-size:10.5pt"><span style="font-family:Calibri"><span style="font-size:10.5000pt"><span style="font-family:宋体"><font face="宋体">值之和。</font></span></span></span></span></p>
<p>提醒一下,二叉搜索树满足下列约束条件:</p>
<ul>
<li>节点的左子树仅包含键<strong> 小于 </strong>节点键的节点。</li>
<li>节点的右子树仅包含键<strong> 大于</strong> 节点键的节点。</li>
<li>左右子树也必须是二叉搜索树。</li>
</ul>
<p><strong>注意:</strong>该题目与 538: <a href="https://leetcode-cn.com/problems/convert-bst-to-greater-tree/">https://leetcode-cn.com/problems/convert-bst-to-greater-tree/  </a>相同</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/05/03/tree.png" style="height: 364px; width: 534px;" /></strong></p>
<pre>
<strong>输入:</strong>[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
<strong>输出:</strong>[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = [0,null,1]
<strong>输出:</strong>[1,null,1]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [1,0,2]
<strong>输出:</strong>[3,3,2]
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>root = [3,2,4,1]
<strong>输出:</strong>[7,9,4,10]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的节点数介于 <code>1</code><code>100</code> 之间。</li>
<li>每个节点的值介于 <code>0</code> 和 <code>100</code> 之间。</li>
<li>树中的所有值 <strong>互不相同</strong></li>
<li>给定的树为二叉搜索树。</li>
</ul>
<p>给定&nbsp;<code>N</code>,想象一个凸&nbsp;<code>N</code>&nbsp;边多边形,其顶点按顺时针顺序依次标记为&nbsp;<code>A[0], A[i], ..., A[N-1]</code></p>
<p>假设您将多边形剖分为 <code>N-2</code> 个三角形。对于每个三角形,该三角形的值是顶点标记的<strong>乘积</strong>,三角剖分的分数是进行三角剖分后所有 <code>N-2</code> 个三角形的值之和。</p>
<p>返回多边形进行三角剖分后可以得到的最低分。<br>
&nbsp;</p>
<ol>
</ol>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[1,2,3]
<strong>输出:</strong>6
<strong>解释:</strong>多边形已经三角化,唯一三角形的分数为 6。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/05/03/minimum-score-triangulation-of-polygon-1.png" style="height: 150px; width: 253px;"></p>
<pre><strong>输入:</strong>[3,7,4,5]
<strong>输出:</strong>144
<strong>解释:</strong>有两种三角剖分,可能得分分别为:3*7*5 + 4*5*7 = 245,或 3*4*5 + 3*4*7 = 144。最低分数为 144。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>[1,3,1,4,1,5]
<strong>输出:</strong>13
<strong>解释:</strong>最低分数三角剖分的得分情况为 1*1*3 + 1*1*4 + 1*1*5 + 1*1*1 = 13。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>3 &lt;= A.length &lt;= 50</code></li>
<li><code>1 &lt;= A[i] &lt;= 100</code></li>
</ol>
<p>在一个长度 <strong>无限 </strong>的数轴上,第 <code>i</code> 颗石子的位置为 <code>stones[i]</code>。如果一颗石子的位置最小/最大,那么该石子被称作 <strong>端点石子 </strong></p>
<p>每个回合,你可以将一颗端点石子拿起并移动到一个未占用的位置,使得该石子不再是一颗端点石子。</p>
<p>值得注意的是,如果石子像 <code>stones = [1,2,5]</code> 这样,你将 <strong>无法 </strong>移动位于位置 5 的端点石子,因为无论将它移动到任何位置(例如 0 或 3),该石子都仍然会是端点石子。</p>
<p>当你无法进行任何移动时,即,这些石子的位置连续时,游戏结束。</p>
<p>要使游戏结束,你可以执行的最小和最大移动次数分别是多少? 以长度为 2 的数组形式返回答案:<code>answer = [minimum_moves, maximum_moves]</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>[7,4,9]
<strong>输出:</strong>[1,2]
<strong>解释:</strong>
我们可以移动一次,4 -> 8,游戏结束。
或者,我们可以移动两次 9 -> 5,4 -> 6,游戏结束。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>[6,5,4,3,10]
<strong>输出:</strong>[2,3]
<strong>解释:</strong>
我们可以移动 3 -> 8,接着是 10 -> 7,游戏结束。
或者,我们可以移动 3 -> 7, 4 -> 8, 5 -> 9,游戏结束。
注意,我们无法进行 10 -> 2 这样的移动来结束游戏,因为这是不合要求的移动。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>[100,101,104,102,103]
<strong>输出:</strong>[0,0]</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 <= stones.length <= 10^4</code></li>
<li><code>1 <= stones[i] <= 10^9</code></li>
<li><code>stones[i]</code> 的值各不相同。</li>
</ul>
<p> </p>
<p>给定一个二叉树,找出其最大深度。</p>
<p>二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。</p>
<p><strong>说明:</strong>&nbsp;叶子节点是指没有子节点的节点。</p>
<p><strong>示例:</strong><br>
给定二叉树 <code>[3,9,20,null,null,15,7]</code></p>
<pre> 3
/ \
9 20
/ \
15 7</pre>
<p>返回它的最大深度&nbsp;3 。</p>
<p>有一堆石头,用整数数组 <code>stones</code> 表示。其中 <code>stones[i]</code> 表示第 <code>i</code> 块石头的重量。</p>
<p>每一回合,从中选出<strong>任意两块石头</strong>,然后将它们一起粉碎。假设石头的重量分别为 <code>x</code> 和 <code>y</code>,且 <code>x <= y</code>。那么粉碎的可能结果如下:</p>
<ul>
<li>如果 <code>x == y</code>,那么两块石头都会被完全粉碎;</li>
<li>如果 <code>x != y</code>,那么重量为 <code>x</code> 的石头将会完全粉碎,而重量为 <code>y</code> 的石头新重量为 <code>y-x</code></li>
</ul>
<p>最后,<strong>最多只会剩下一块 </strong>石头。返回此石头 <strong>最小的可能重量 </strong>。如果没有石头剩下,就返回 <code>0</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>stones = [2,7,4,1,8,1]
<strong>输出:</strong>1
<strong>解释:</strong>
组合 2 和 4,得到 2,所以数组转化为 [2,7,1,8,1],
组合 7 和 8,得到 1,所以数组转化为 [2,1,1,1],
组合 2 和 1,得到 1,所以数组转化为 [1,1,1],
组合 1 和 1,得到 0,所以数组转化为 [1],这就是最优值。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>stones = [31,26,33,21,40]
<strong>输出:</strong>5
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>stones = [1,2]
<strong>输出:</strong>1
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= stones.length <= 30</code></li>
<li><code>1 <= stones[i] <= 100</code></li>
</ul>
<p>给定一棵树的前序遍历 <code>preorder</code> 与中序遍历  <code>inorder</code>。请构造二叉树并返回其根节点。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" />
<pre>
<strong>Input:</strong> preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
<strong>Output:</strong> [3,9,20,null,null,15,7]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>Input:</strong> preorder = [-1], inorder = [-1]
<strong>Output:</strong> [-1]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= preorder.length <= 3000</code></li>
<li><code>inorder.length == preorder.length</code></li>
<li><code>-3000 <= preorder[i], inorder[i] <= 3000</code></li>
<li><code>preorder</code> 和 <code>inorder</code> 均无重复元素</li>
<li><code>inorder</code> 均出现在 <code>preorder</code></li>
<li><code>preorder</code> 保证为二叉树的前序遍历序列</li>
<li><code>inorder</code> 保证为二叉树的中序遍历序列</li>
</ul>
<p>学校打算为全体学生拍一张年度纪念照。根据要求,学生需要按照 <strong>非递减</strong> 的高度顺序排成一行。</p>
<p>排序后的高度情况用整数数组 <code>expected</code> 表示,其中 <code>expected[i]</code> 是预计排在这一行中第 <code>i</code> 位的学生的高度(<strong>下标从 0 开始</strong>)。</p>
<p>给你一个整数数组 <code>heights</code> ,表示 <strong>当前学生站位</strong> 的高度情况。<code>heights[i]</code> 是这一行中第 <code>i</code> 位学生的高度(<strong>下标从 0 开始</strong>)。</p>
<p>返回满足<em> </em><code>heights[i] != expected[i]</code><strong>下标数量</strong></p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入:</strong>heights =&nbsp;[1,1,4,2,1,3]
<strong>输出:</strong>3
<strong>解释:</strong>
高度:[1,1,<em><strong>4</strong></em>,2,<em><strong>1</strong></em>,<em><strong>3</strong></em>]
预期:[1,1,<em><strong>1</strong></em>,2,<em><strong>3</strong></em>,<em><strong>4</strong></em>]
下标 2 、4 、5 处的学生高度不匹配。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>heights = [5,1,2,3,4]
<strong>输出:</strong>5
<strong>解释:</strong>
高度:[<em><strong>5</strong></em>,<em><strong>1</strong></em>,<em><strong>2</strong></em>,<em><strong>3</strong></em>,<em><strong>4</strong></em>]
预期:[<em><strong>1</strong></em>,<em><strong>2</strong></em>,<em><strong>3</strong></em>,<em><strong>4</strong></em>,<em><strong>5</strong></em>]
所有下标的对应学生高度都不匹配。</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>heights = [1,2,3,4,5]
<strong>输出:</strong>0
<strong>解释:</strong>
高度:[1,2,3,4,5]
预期:[1,2,3,4,5]
所有下标的对应学生高度都匹配。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= heights.length &lt;= 100</code></li>
<li><code>1 &lt;= heights[i] &lt;= 100</code></li>
</ul>
<p>今天,书店老板有一家店打算试营业 <code>customers.length</code> 分钟。每分钟都有一些顾客(<code>customers[i]</code>)会进入书店,所有这些顾客都会在那一分钟结束后离开。</p>
<p>在某些时候,书店老板会生气。 如果书店老板在第 <code>i</code> 分钟生气,那么 <code>grumpy[i] = 1</code>,否则 <code>grumpy[i] = 0</code>。 当书店老板生气时,那一分钟的顾客就会不满意,不生气则他们是满意的。</p>
<p>书店老板知道一个秘密技巧,能抑制自己的情绪,可以让自己连续 <code>X</code> 分钟不生气,但却只能使用一次。</p>
<p>请你返回这一天营业下来,最多有多少客户能够感到满意。<br />
 </p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入:</strong>customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3
<strong>输出:</strong>16
<strong>解释:
</strong>书店老板在最后 3 分钟保持冷静。
感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= X <= customers.length == grumpy.length <= 20000</code></li>
<li><code>0 <customers[i] <= 1000</code></li>
<li><code>0 <grumpy[i] <= 1</code></li>
</ul>
<p>给你一个正整数的数组 <code>A</code>(其中的元素不一定完全不同),请你返回可在 <strong>一次交换</strong>(交换两数字 <code>A[i]</code><code>A[j]</code> 的位置)后得到的、按字典序排列小于 <code>A</code> 的最大可能排列。</p>
<p>如果无法这么操作,就请返回原数组。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>arr = [3,2,1]
<strong>输出:</strong>[3,1,2]
<strong>解释:</strong>交换 2 和 1
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,1,5]
<strong>输出:</strong>[1,1,5]
<strong>解释:</strong>已经是最小排列
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,9,4,6,7]
<strong>输出:</strong>[1,7,4,6,9]
<strong>解释:</strong>交换 9 和 7
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>arr = [3,1,1,3]
<strong>输出:</strong>[1,3,1,3]
<strong>解释:</strong>交换 1 和 3
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= arr.length <= 10<sup>4</sup></code></li>
<li><code>1 <= arr[i] <= 10<sup>4</sup></code></li>
</ul>
<p>在一个仓库里,有一排条形码,其中第 <code>i</code> 个条形码为&nbsp;<code>barcodes[i]</code></p>
<p>请你重新排列这些条形码,使其中两个相邻的条形码 <strong>不能</strong> 相等。 你可以返回任何满足该要求的答案,此题保证存在答案。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[1,1,1,2,2,2]
<strong>输出:</strong>[2,1,2,1,2,1]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[1,1,1,1,2,2,3,3]
<strong>输出:</strong>[1,3,1,3,2,1,2,1]</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= barcodes.length &lt;= 10000</code></li>
<li><code>1 &lt;= barcodes[i] &lt;= 10000</code></li>
</ol>
<p>&nbsp;</p>
<p>根据一棵树的中序遍历与后序遍历构造二叉树。</p>
<p><strong>注意:</strong><br>
你可以假设树中没有重复的元素。</p>
<p>例如,给出</p>
<pre>中序遍历 inorder =&nbsp;[9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]</pre>
<p>返回如下的二叉树:</p>
<pre> 3
/ \
9 20
/ \
15 7
</pre>
<p>给定一个二叉树,返回其节点值自底向上的层序遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)</p>
<p>例如:<br />
给定二叉树 <code>[3,9,20,null,null,15,7]</code>,</p>
<pre>
3
/ \
9 20
/ \
15 7
</pre>
<p>返回其自底向上的层序遍历为:</p>
<pre>
[
[15,7],
[9,20],
[3]
]
</pre>
<p>对于字符串 <code>S</code> 和 <code>T</code>,只有在 <code>S = T + ... + T</code><code>T</code> 自身连接 1 次或多次)时,我们才认定 “<code>T</code> 能除尽 <code>S</code>”。</p>
<p>返回最长字符串 <code>X</code>,要求满足 <code>X</code> 能除尽 <code>str1</code> 且 <code>X</code> 能除尽 <code>str2</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>str1 = "ABCABC", str2 = "ABC"
<strong>输出:</strong>"ABC"
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>str1 = "ABABAB", str2 = "ABAB"
<strong>输出:</strong>"AB"
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>str1 = "LEET", str2 = "CODE"
<strong>输出:</strong>""
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 <= str1.length <= 1000</code></li>
<li><code>1 <= str2.length <= 1000</code></li>
<li><code>str1[i]</code> 和 <code>str2[i]</code> 为大写英文字母</li>
</ol>
<p>给定由若干 0 和 1 组成的矩阵 <code>matrix</code>,从中选出任意数量的列并翻转其上的 <strong>每个 </strong>单元格。翻转后,单元格的值从 0 变成 1,或者从 1 变为 0 。</p>
<p>回经过一些翻转后,行与行之间所有值都相等的最大行数。</p>
<p> </p>
<ol>
</ol>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>[[0,1],[1,1]]
<strong>输出:</strong>1
<strong>解释:</strong>不进行翻转,有 1 行所有值都相等。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>[[0,1],[1,0]]
<strong>输出:</strong>2
<strong>解释:</strong>翻转第一列的值之后,这两行都由相等的值组成。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>[[0,0,0],[0,0,1],[1,1,0]]
<strong>输出:</strong>2
<strong>解释:</strong>翻转前两列的值之后,后两行由相等的值组成。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 <= matrix.length <= 300</code></li>
<li><code>1 <= matrix[i].length <= 300</code></li>
<li>所有 <code>matrix[i].length</code> 都相等</li>
<li><code>matrix[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
</ol>
<p>给出基数为 <strong>-2</strong>&nbsp;的两个数&nbsp;<code>arr1</code>&nbsp;<code>arr2</code>,返回两数相加的结果。</p>
<p>数字以&nbsp;<strong>数组形式&nbsp;</strong>给出:数组由若干 0 和 1 组成,按最高有效位到最低有效位的顺序排列。例如,<code>arr&nbsp;= [1,1,0,1]</code>&nbsp;表示数字&nbsp;<code>(-2)^3&nbsp;+ (-2)^2 + (-2)^0 = -3</code><strong>数组形式&nbsp;</strong>的数字也同样不含前导零:以 <code>arr</code> 为例,这意味着要么&nbsp;<code>arr == [0]</code>,要么&nbsp;<code>arr[0] == 1</code></p>
<p>返回相同表示形式的 <code>arr1</code><code>arr2</code> 相加的结果。两数的表示形式为:不含前导零、由若干 0 和 1 组成的数组。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,1,1,1,1], arr2 = [1,0,1]
<strong>输出:</strong>[1,0,0,0,0]
<strong>解释:</strong>arr1 表示 11,arr2 表示 5,输出表示 16 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= arr1.length &lt;= 1000</code></li>
<li><code>1 &lt;= arr2.length &lt;= 1000</code></li>
<li><code>arr1</code>&nbsp;<code>arr2</code>&nbsp;都不含前导零</li>
<li><code>arr1[i]</code>&nbsp;<code>0</code>&nbsp;&nbsp;<code>1</code></li>
<li><code>arr2[i]</code>&nbsp;&nbsp;<code>0</code>&nbsp;<code>1</code></li>
</ol>
<p>给出矩阵 <code>matrix</code> 和目标值 <code>target</code>,返回元素总和等于目标值的非空子矩阵的数量。</p>
<p>子矩阵 <code>x1, y1, x2, y2</code> 是满足 <code>x1 <= x <= x2</code> 且 <code>y1 <= y <= y2</code> 的所有单元 <code>matrix[x][y]</code> 的集合。</p>
<p>如果 <code>(x1, y1, x2, y2)</code> 和 <code>(x1', y1', x2', y2')</code> 两个子矩阵中部分坐标不同(如:<code>x1 != x1'</code>),那么这两个子矩阵也不同。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/09/02/mate1.jpg" style="width: 242px; height: 242px;" /></p>
<pre>
<strong>输入:</strong>matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
<strong>输出:</strong>4
<strong>解释:</strong>四个只含 0 的 1x1 子矩阵。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>matrix = [[1,-1],[-1,1]], target = 0
<strong>输出:</strong>5
<strong>解释:</strong>两个 1x2 子矩阵,加上两个 2x1 子矩阵,再加上一个 2x2 子矩阵。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>matrix = [[904]], target = 0
<strong>输出:</strong>0
</pre>
<p> </p>
<p><strong><strong>提示:</strong></strong></p>
<ul>
<li><code>1 <= matrix.length <= 100</code></li>
<li><code>1 <= matrix[0].length <= 100</code></li>
<li><code>-1000 <= matrix[i] <= 1000</code></li>
<li><code>-10^8 <= target <= 10^8</code></li>
</ul>
<p>给出第一个词&nbsp;<code>first</code> 和第二个词&nbsp;<code>second</code>,考虑在某些文本&nbsp;<code>text</code>&nbsp;中可能以 &quot;<code>first second third</code>&quot; 形式出现的情况,其中&nbsp;<code>second</code>&nbsp;紧随&nbsp;<code>first</code>&nbsp;出现,<code>third</code>&nbsp;紧随&nbsp;<code>second</code>&nbsp;出现。</p>
<p>对于每种这样的情况,将第三个词 &quot;<code>third</code>&quot; 添加到答案中,并返回答案。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>text = &quot;alice is a good girl she is a good student&quot;, first = &quot;a&quot;, second = &quot;good&quot;
<strong>输出:</strong>[&quot;girl&quot;,&quot;student&quot;]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>text = &quot;we will we will rock you&quot;, first = &quot;we&quot;, second = &quot;will&quot;
<strong>输出:</strong>[&quot;we&quot;,&quot;rock&quot;]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= text.length &lt;= 1000</code></li>
<li><code>text</code>&nbsp;由一些用空格分隔的单词组成,每个单词都由小写英文字母组成</li>
<li><code>1 &lt;= first.length, second.length &lt;= 10</code></li>
<li><code>first</code>&nbsp;<code>second</code>&nbsp;由小写英文字母组成</li>
</ol>
<p>你有一套活字字模&nbsp;<code>tiles</code>,其中每个字模上都刻有一个字母&nbsp;<code>tiles[i]</code>。返回你可以印出的非空字母序列的数目。</p>
<p><strong>注意:</strong>本题中,每个活字字模只能使用一次。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>&quot;AAB&quot;
<strong>输出:</strong>8
<strong>解释:</strong>可能的序列为 &quot;A&quot;, &quot;B&quot;, &quot;AA&quot;, &quot;AB&quot;, &quot;BA&quot;, &quot;AAB&quot;, &quot;ABA&quot;, &quot;BAA&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>&quot;AAABBC&quot;
<strong>输出:</strong>188
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= tiles.length &lt;= 7</code></li>
<li><code>tiles</code> 由大写英文字母组成</li>
</ol>
<p>给定一棵二叉树的根 <code>root</code>,请你考虑它所有&nbsp;<strong>从根到叶的路径</strong>:从根到任何叶的路径。(所谓一个叶子节点,就是一个没有子节点的节点)</p>
<p>假如通过节点 <code>node</code> 的每种可能的 &ldquo;根-叶&rdquo; 路径上值的总和全都小于给定的 <code>limit</code>,则该节点被称之为「不足节点」,需要被删除。</p>
<p>请你删除所有不足节点,并返回生成的二叉树的根。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/08/insufficient-1.png" style="height: 200px; width: 482px;">
输入:</strong>root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1
<strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/08/insufficient-2.png" style="height: 200px; width: 258px;">
输出:</strong>[1,2,3,4,null,null,7,8,9,null,14]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/08/insufficient-3.png" style="height: 200px; width: 292px;">
输入:</strong>root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22
<strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/08/insufficient-4.png" style="height: 200px; width: 264px;">
输出:</strong>[5,4,8,11,null,17,4,7,null,null,null,5]</pre>
<p><strong>示例 3:</strong></p>
<pre><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/08/insufficient-5.png" style="height: 100px; width: 140px;">
输入:</strong>root = [5,-6,-6], limit = 0<strong>
输出:</strong>[]</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li>给定的树有&nbsp;<code>1</code>&nbsp;&nbsp;<code>5000</code>&nbsp;个节点</li>
<li><code>-10^5&nbsp;&lt;= node.val &lt;= 10^5</code></li>
<li><code>-10^9 &lt;= limit&nbsp;&lt;= 10^9</code></li>
</ol>
<p>&nbsp;</p>
<p>给你一个整数数组 <code>nums</code> ,其中元素已经按 <strong>升序</strong> 排列,请你将其转换为一棵 <strong>高度平衡</strong> 二叉搜索树。</p>
<p><strong>高度平衡 </strong>二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg" style="width: 302px; height: 222px;" />
<pre>
<strong>输入:</strong>nums = [-10,-3,0,5,9]
<strong>输出:</strong>[0,-3,9,-10,null,5]
<strong>解释:</strong>[0,-10,5,null,-3,null,9] 也将被视为正确答案:
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg" style="width: 302px; height: 222px;" />
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree.jpg" style="width: 342px; height: 142px;" />
<pre>
<strong>输入:</strong>nums = [1,3]
<strong>输出:</strong>[3,1]
<strong>解释:</strong>[1,3] 和 [3,1] 都是高度平衡二叉搜索树。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
<li><code>nums</code><strong>严格递增</strong> 顺序排列</li>
</ul>
<p>返回 <code>s</code> 字典序最小的子序列,该子序列包含 <code>s</code> 的所有不同字符,且只包含一次。</p>
<p><strong>注意:</strong>该题与 316 <a href="https://leetcode.com/problems/remove-duplicate-letters/">https://leetcode.com/problems/remove-duplicate-letters/</a> 相同</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong><code>s = "bcabc"</code>
<strong>输出<code></code></strong><code>"abc"</code>
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong><code>s = "cbacdcbc"</code>
<strong>输出:</strong><code>"acdb"</code></pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 1000</code></li>
<li><code>s</code> 由小写英文字母组成</li>
</ul>
<p>给你一个长度固定的整数数组&nbsp;<code>arr</code>,请你将该数组中出现的每个零都复写一遍,并将其余的元素向右平移。</p>
<p>注意:请不要在超过该数组长度的位置写入元素。</p>
<p>要求:请对输入的数组&nbsp;<strong>就地&nbsp;</strong>进行上述修改,不要从函数返回任何东西。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>[1,0,2,3,0,4,5,0]
<strong>输出:</strong>null
<strong>解释:</strong>调用函数后,<strong>输入</strong>的数组将被修改为:[1,0,0,2,3,0,0,4]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>[1,2,3]
<strong>输出:</strong>null
<strong>解释:</strong>调用函数后,<strong>输入</strong>的数组将被修改为:[1,2,3]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= arr.length &lt;= 10000</code></li>
<li><code>0 &lt;= arr[i] &lt;= 9</code></li>
</ol>
<p>我们有一个项的集合,其中第&nbsp;<code>i</code>&nbsp;项的值为&nbsp;<code>values[i]</code>,标签为&nbsp;<code>labels[i]</code></p>
<p>我们从这些项中选出一个子集&nbsp;<code>S</code>,这样一来:</p>
<ul>
<li><code>|S| &lt;= num_wanted</code></li>
<li>对于任意的标签 <code>L</code>,子集 <code>S</code> 中标签为 <code>L</code>&nbsp;的项的数目总满足&nbsp;<code>&lt;= use_limit</code></li>
</ul>
<p>返回子集&nbsp;<code>S</code>&nbsp;的最大可能的&nbsp;<strong></strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>values = [5,4,3,2,1], labels = [1,1,2,2,3], <code>num_wanted </code>= 3, use_limit = 1
<strong>输出:</strong>9
<strong>解释:</strong>选出的子集是第一项,第三项和第五项。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>values = [5,4,3,2,1], labels = [1,3,3,3,2], <code>num_wanted </code>= 3, use_limit = 2
<strong>输出:</strong>12
<strong>解释:</strong>选出的子集是第一项,第二项和第三项。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>values = [9,8,8,7,6], labels = [0,0,0,1,1], <code>num_wanted </code>= 3, use_limit = 1
<strong>输出:</strong>16
<strong>解释:</strong>选出的子集是第一项和第四项。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>values = [9,8,8,7,6], labels = [0,0,0,1,1], <code>num_wanted </code>= 3, use_limit = 2
<strong>输出:</strong>24
<strong>解释:</strong>选出的子集是第一项,第二项和第四项。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= values.length == labels.length &lt;= 20000</code></li>
<li><code>0 &lt;= values[i], labels[i]&nbsp;&lt;= 20000</code></li>
<li><code>1 &lt;= num_wanted, use_limit&nbsp;&lt;= values.length</code></li>
</ol>
<p>给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。</p>
<p>本题中,一个高度平衡二叉树是指一个二叉树<em>每个节点&nbsp;</em>的左右两个子树的高度差的绝对值不超过 1。</p>
<p><strong>示例:</strong></p>
<pre>给定的有序链表: [-10, -3, 0, 5, 9],
一个可能的答案是:[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树:
0
/ \
-3 9
/ /
-10 5
</pre>
<p>给你一个 <code>n x n</code> 的二进制矩阵 <code>grid</code> 中,返回矩阵中最短 <strong>畅通路径</strong> 的长度。如果不存在这样的路径,返回 <code>-1</code></p>
<p>二进制矩阵中的 畅通路径 是一条从 <strong>左上角</strong> 单元格(即,<code>(0, 0)</code>)到 右下角 单元格(即,<code>(n - 1, n - 1)</code>)的路径,该路径同时满足下述要求:</p>
<ul>
<li>路径途经的所有单元格都的值都是 <code>0</code></li>
<li>路径中所有相邻的单元格应当在 <strong>8 个方向之一</strong> 上连通(即,相邻两单元之间彼此不同且共享一条边或者一个角)。</li>
</ul>
<p><strong>畅通路径的长度</strong> 是该路径途经的单元格总数。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example1_1.png" style="width: 500px; height: 234px;" />
<pre>
<strong>输入:</strong>grid = [[0,1],[1,0]]
<strong>输出:</strong>2
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example2_1.png" style="height: 216px; width: 500px;" />
<pre>
<strong>输入:</strong>grid = [[0,0,0],[1,1,0],[1,1,0]]
<strong>输出:</strong>4
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>grid = [[1,0,0],[1,1,0],[1,1,0]]
<strong>输出:</strong>-1
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == grid.length</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>1 <= n <= 100</code></li>
<li><code>grid[i][j]</code><code>0</code><code>1</code></li>
</ul>
<p>给出两个字符串&nbsp;<code>str1</code>&nbsp;<code>str2</code>,返回同时以&nbsp;<code>str1</code>&nbsp;&nbsp;<code>str2</code>&nbsp;作为子序列的最短字符串。如果答案不止一个,则可以返回满足条件的任意一个答案。</p>
<p>(如果从字符串 T 中删除一些字符(也可能不删除,并且选出的这些字符可以位于 T 中的&nbsp;<strong>任意位置</strong>),可以得到字符串 S,那么&nbsp;S 就是&nbsp;T 的子序列)</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>str1 = &quot;abac&quot;, str2 = &quot;cab&quot;
<strong>输出:</strong>&quot;cabac&quot;
<strong>解释:</strong>
str1 = &quot;abac&quot;&quot;cabac&quot; 的一个子串,因为我们可以删去 &quot;cabac&quot; 的第一个 &quot;c&quot;得到 &quot;abac&quot;
str2 = &quot;cab&quot;&quot;cabac&quot; 的一个子串,因为我们可以删去 &quot;cabac&quot; 末尾的 &quot;ac&quot; 得到 &quot;cab&quot;
最终我们给出的答案是满足上述属性的最短字符串。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= str1.length, str2.length &lt;= 1000</code></li>
<li><code>str1</code>&nbsp;<code>str2</code>&nbsp;都由小写英文字母组成。</li>
</ol>
<p>我们对&nbsp;<code>0</code>&nbsp;&nbsp;<code>255</code>&nbsp;之间的整数进行采样,并将结果存储在数组&nbsp;<code>count</code>&nbsp;中:<code>count[k]</code>&nbsp;就是整数&nbsp;<code>k</code> 的采样个数。</p>
<p>我们以&nbsp;<strong>浮点数&nbsp;</strong>数组的形式,分别返回样本的最小值、最大值、平均值、中位数和众数。其中,众数是保证唯一的。</p>
<p>我们先来回顾一下中位数的知识:</p>
<ul>
<li>如果样本中的元素有序,并且元素数量为奇数时,中位数为最中间的那个元素;</li>
<li>如果样本中的元素有序,并且元素数量为偶数时,中位数为中间的两个元素的平均值。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>count = [0,1,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
<strong>输出:</strong>[1.00000,3.00000,2.37500,2.50000,3.00000]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>count = [0,4,3,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
<strong>输出:</strong>[1.00000,4.00000,2.18182,2.00000,1.00000]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>count.length == 256</code></li>
<li><code>1 &lt;= sum(count) &lt;= 10^9</code></li>
<li>计数表示的众数是唯一的</li>
<li>答案与真实值误差在&nbsp;<code>10^-5</code>&nbsp;以内就会被视为正确答案</li>
</ol>
<p>假设你是一位顺风车司机,车上最初有&nbsp;<code>capacity</code>&nbsp;个空座位可以用来载客。由于道路的限制,车&nbsp;<strong>只能&nbsp;</strong>向一个方向行驶(也就是说,<strong>不允许掉头或改变方向</strong>,你可以将其想象为一个向量)。</p>
<p>这儿有一份乘客行程计划表&nbsp;<code>trips[][]</code>,其中&nbsp;<code>trips[i] = [num_passengers, start_location, end_location]</code>&nbsp;包含了第 <code>i</code> 组乘客的行程信息:</p>
<ul>
<li>必须接送的乘客数量;</li>
<li>乘客的上车地点;</li>
<li>以及乘客的下车地点。</li>
</ul>
<p>这些给出的地点位置是从你的&nbsp;<strong>初始&nbsp;</strong>出发位置向前行驶到这些地点所需的距离(它们一定在你的行驶方向上)。</p>
<p>请你根据给出的行程计划表和车子的座位数,来判断你的车是否可以顺利完成接送所有乘客的任务(当且仅当你可以在所有给定的行程中接送所有乘客时,返回&nbsp;<code>true</code>,否则请返回 <code>false</code>)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>trips = [[2,1,5],[3,3,7]], capacity = 4
<strong>输出:</strong>false
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>trips = [[2,1,5],[3,3,7]], capacity = 5
<strong>输出:</strong>true
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>trips = [[2,1,5],[3,5,7]], capacity = 3
<strong>输出:</strong>true
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>trips = [[3,2,7],[3,7,9],[8,3,9]], capacity = 11
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>你可以假设乘客会自觉遵守 &ldquo;<strong>先下后上</strong>&rdquo; 的良好素质</li>
<li><code>trips.length &lt;= 1000</code></li>
<li><code>trips[i].length == 3</code></li>
<li><code>1 &lt;= trips[i][0] &lt;= 100</code></li>
<li><code>0 &lt;= trips[i][1] &lt; trips[i][2] &lt;= 1000</code></li>
<li><code>1 &lt;=&nbsp;capacity &lt;= 100000</code></li>
</ul>
<p>(这是一个 <strong>交互式问题&nbsp;</strong></p>
<p>给你一个 <strong>山脉数组</strong>&nbsp;<code>mountainArr</code>,请你返回能够使得&nbsp;<code>mountainArr.get(index)</code>&nbsp;<strong>等于</strong>&nbsp;<code>target</code>&nbsp;<strong>最小</strong>&nbsp;的下标 <code>index</code>&nbsp;值。</p>
<p>如果不存在这样的下标 <code>index</code>,就请返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p>何为山脉数组?如果数组&nbsp;<code>A</code> 是一个山脉数组的话,那它满足如下条件:</p>
<p><strong>首先</strong><code>A.length &gt;= 3</code></p>
<p><strong>其次</strong>,在&nbsp;<code>0 &lt; i&nbsp;&lt; A.length - 1</code>&nbsp;条件下,存在 <code>i</code> 使得:</p>
<ul>
<li><code>A[0] &lt; A[1] &lt; ... A[i-1] &lt; A[i]</code></li>
<li><code>A[i] &gt; A[i+1] &gt; ... &gt; A[A.length - 1]</code></li>
</ul>
<p>&nbsp;</p>
<p>你将&nbsp;<strong>不能直接访问该山脉数组</strong>,必须通过&nbsp;<code>MountainArray</code>&nbsp;接口来获取数据:</p>
<ul>
<li><code>MountainArray.get(k)</code>&nbsp;- 会返回数组中索引为<code>k</code>&nbsp;的元素(下标从 0 开始)</li>
<li><code>MountainArray.length()</code>&nbsp;- 会返回该数组的长度</li>
</ul>
<p>&nbsp;</p>
<p><strong>注意:</strong></p>
<p>&nbsp;<code>MountainArray.get</code>&nbsp;发起超过 <code>100</code> 次调用的提交将被视为错误答案。此外,任何试图规避判题系统的解决方案都将会导致比赛资格被取消。</p>
<p>为了帮助大家更好地理解交互式问题,我们准备了一个样例 &ldquo;<strong>答案</strong>&rdquo;<a href="https://leetcode-cn.com/playground/RKhe3ave" target="_blank">https://leetcode-cn.com/playground/RKhe3ave</a>,请注意这 <strong>不是一个正确答案</strong></p>
<ol>
</ol>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>array = [1,2,3,4,5,3,1], target = 3
<strong>输出:</strong>2
<strong>解释:</strong>3 在数组中出现了两次,下标分别为 2 和 5,我们返回最小的下标 2。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>array = [0,1,2,4,2,1], target = 3
<strong>输出:</strong>-1
<strong>解释:</strong>3 在数组中没有出现,返回 -1。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 &lt;= mountain_arr.length() &lt;= 10000</code></li>
<li><code>0 &lt;= target &lt;= 10^9</code></li>
<li><code>0 &lt;= mountain_arr.get(index) &lt;=&nbsp;10^9</code></li>
</ul>
<p>如果你熟悉 Shell 编程,那么一定了解过花括号展开,它可以用来生成任意字符串。</p>
<p>花括号展开的表达式可以看作一个由 <strong>花括号</strong><strong>逗号</strong><strong>小写英文字母</strong> 组成的字符串,定义下面几条语法规则:</p>
<ul>
<li>如果只给出单一的元素&nbsp;<code>x</code>,那么表达式表示的字符串就只有&nbsp;<code>"x"</code><code>R(x) = {x}</code>
<ul>
<li>例如,表达式 <code>"a"</code> 表示字符串 <code>"a"</code></li>
<li>而表达式 <code>"w"</code> 就表示字符串 <code>"w"</code></li>
</ul>
</li>
<li>当两个或多个表达式并列,以逗号分隔,我们取这些表达式中元素的并集。<code>R({e_1,e_2,...}) = R(e_1)&nbsp;∪ R(e_2)&nbsp;∪ ...</code>
<ul>
<li>例如,表达式 <code>"{a,b,c}"</code> 表示字符串&nbsp;<code>"a","b","c"</code></li>
<li>而表达式 <code>"{{a,b},{b,c}}"</code> 也可以表示字符串&nbsp;<code>"a","b","c"</code></li>
</ul>
</li>
<li>要是两个或多个表达式相接,中间没有隔开时,我们从这些表达式中各取一个元素依次连接形成字符串。<code>R(e_1 + e_2) = {a + b for (a, b) in&nbsp;R(e_1)&nbsp;× R(e_2)}</code>
<ul>
<li>例如,表达式 <code>"{a,b}{c,d}"</code> 表示字符串&nbsp;<code>"ac","ad","bc","bd"</code></li>
</ul>
</li>
<li>表达式之间允许嵌套,单一元素与表达式的连接也是允许的。
<ul>
<li>例如,表达式 <code>"a{b,c,d}"</code> 表示字符串&nbsp;<code>"ab","ac","ad"​​​​​​</code></li>
<li>例如,表达式 <code>"a{b,c}{d,e}f{g,h}"</code> 可以表示字符串&nbsp;<code>"abdfg", "abdfh", "abefg", "abefh", "acdfg", "acdfh", "acefg", "acefh"</code></li>
</ul>
</li>
</ul>
<p>给出表示基于给定语法规则的表达式&nbsp;<code>expression</code>,返回它所表示的所有字符串组成的有序列表。</p>
<p>假如你希望以「集合」的概念了解此题,也可以通过点击 “<strong>显示英文描述</strong>” 获取详情。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>expression = "{a,b}{c,{d,e}}"
<strong>输出:</strong>["ac","ad","ae","bc","bd","be"]</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>expression = "{{a,z},a{b,c},{ab,z}}"
<strong>输出:</strong>["a","ab","ac","z"]
<strong>解释:</strong>输出中 <strong>不应 </strong>出现重复的组合结果。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= expression.length &lt;= 60</code></li>
<li><code>expression[i]</code><code>'{'</code><code>'}'</code><code>','</code>&nbsp;或小写英文字母组成</li>
<li>给出的表达式&nbsp;<code>expression</code>&nbsp;用以表示一组基于题目描述中语法构造的字符串</li>
</ul>
<p>给定一个二叉树,判断它是否是高度平衡的二叉树。</p>
<p>本题中,一棵高度平衡二叉树定义为:</p>
<blockquote>
<p>一个二叉树<em>每个节点 </em>的左右两个子树的高度差的绝对值不超过 1 。</p>
</blockquote>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg" style="width: 342px; height: 221px;" />
<pre>
<strong>输入:</strong>root = [3,9,20,null,null,15,7]
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg" style="width: 452px; height: 301px;" />
<pre>
<strong>输入:</strong>root = [1,2,2,3,3,null,null,4,4]
<strong>输出:</strong>false
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = []
<strong>输出:</strong>true
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的节点数在范围 <code>[0, 5000]</code></li>
<li><code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code></li>
</ul>
<p>排排坐,分糖果。</p>
<p>我们买了一些糖果 <code>candies</code>,打算把它们分给排好队的 <strong><code>n = num_people</code></strong> 个小朋友。</p>
<p>给第一个小朋友 1 颗糖果,第二个小朋友 2 颗,依此类推,直到给最后一个小朋友 <code>n</code>&nbsp;颗糖果。</p>
<p>然后,我们再回到队伍的起点,给第一个小朋友 <code>n&nbsp;+ 1</code> 颗糖果,第二个小朋友 <code>n&nbsp;+ 2</code> 颗,依此类推,直到给最后一个小朋友 <code>2 * n</code>&nbsp;颗糖果。</p>
<p>重复上述过程(每次都比上一次多给出一颗糖果,当到达队伍终点后再次从队伍起点开始),直到我们分完所有的糖果。注意,就算我们手中的剩下糖果数不够(不比前一次发出的糖果多),这些糖果也会全部发给当前的小朋友。</p>
<p>返回一个长度为 <code>num_people</code>、元素之和为 <code>candies</code> 的数组,以表示糖果的最终分发情况(即 <code>ans[i]</code> 表示第 <code>i</code> 个小朋友分到的糖果数)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>candies = 7, num_people = 4
<strong>输出:</strong>[1,2,3,1]
<strong>解释:</strong>
第一次,ans[0] += 1,数组变为 [1,0,0,0]。
第二次,ans[1] += 2,数组变为 [1,2,0,0]。
第三次,ans[2] += 3,数组变为 [1,2,3,0]。
第四次,ans[3] += 1(因为此时只剩下 1 颗糖果),最终数组变为 [1,2,3,1]。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>candies = 10, num_people = 3
<strong>输出:</strong>[5,2,3]
<strong>解释:</strong>
第一次,ans[0] += 1,数组变为 [1,0,0]。
第二次,ans[1] += 2,数组变为 [1,2,0]。
第三次,ans[2] += 3,数组变为 [1,2,3]。
第四次,ans[0] += 4,最终数组变为 [5,2,3]。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= candies &lt;= 10^9</code></li>
<li><code>1 &lt;= num_people &lt;= 1000</code></li>
</ul>
<p>在一棵无限的二叉树上,每个节点都有两个子节点,树中的节点 <strong>逐行</strong> 依次按&nbsp;&ldquo;&rdquo; 字形进行标记。</p>
<p>如下图所示,在奇数行(即,第一行、第三行、第五行&hellip;&hellip;)中,按从左到右的顺序进行标记;</p>
<p>而偶数行(即,第二行、第四行、第六行&hellip;&hellip;)中,按从右到左的顺序进行标记。</p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/28/tree.png" style="height: 138px; width: 300px;"></p>
<p>给你树上某一个节点的标号 <code>label</code>,请你返回从根节点到该标号为 <code>label</code> 节点的路径,该路径是由途经的节点标号所组成的。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>label = 14
<strong>输出:</strong>[1,3,4,14]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>label = 26
<strong>输出:</strong>[1,2,6,10,26]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= label &lt;= 10^6</code></li>
</ul>
<p>附近的家居城促销,你买回了一直心仪的可调节书架,打算把自己的书都整理到新的书架上。</p>
<p>你把要摆放的书 <code>books</code>&nbsp;都整理好,叠成一摞:从上往下,第 <code>i</code>&nbsp;本书的厚度为 <code>books[i][0]</code>,高度为 <code>books[i][1]</code></p>
<p><strong>按顺序</strong>&nbsp;将这些书摆放到总宽度为&nbsp;<code>shelf_width</code> 的书架上。</p>
<p>先选几本书放在书架上(它们的厚度之和小于等于书架的宽度 <code>shelf_width</code>),然后再建一层书架。重复这个过程,直到把所有的书都放在书架上。</p>
<p>需要注意的是,在上述过程的每个步骤中,<strong>摆放书的顺序与你整理好的顺序相同</strong>。 例如,如果这里有 5 本书,那么可能的一种摆放情况是:第一和第二本书放在第一层书架上,第三本书放在第二层书架上,第四和第五本书放在最后一层书架上。</p>
<p>每一层所摆放的书的最大高度就是这一层书架的层高,书架整体的高度为各层高之和。</p>
<p>以这种方式布置书架,返回书架整体可能的最小高度。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/06/28/shelves.png" style="width: 150px;"></p>
<pre><strong>输入:</strong>books = [[1,1],[2,3],[2,3],[1,1],[1,1],[1,1],[1,2]], shelf_width = 4
<strong>输出:</strong>6
<strong>解释:</strong>
3 层书架的高度和为 1 + 3 + 2 = 6 。
第 2 本书不必放在第一层书架上。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= books.length &lt;= 1000</code></li>
<li><code>1 &lt;= books[i][0] &lt;= shelf_width &lt;= 1000</code></li>
<li><code>1 &lt;= books[i][1] &lt;= 1000</code></li>
</ul>
<p>给你一个以字符串形式表述的&nbsp;<a href="https://baike.baidu.com/item/%E5%B8%83%E5%B0%94%E8%A1%A8%E8%BE%BE%E5%BC%8F/1574380?fr=aladdin" target="_blank">布尔表达式</a>(boolean) <code>expression</code>,返回该式的运算结果。</p>
<p>有效的表达式需遵循以下约定:</p>
<ul>
<li><code>&quot;t&quot;</code>,运算结果为 <code>True</code></li>
<li><code>&quot;f&quot;</code>,运算结果为 <code>False</code></li>
<li><code>&quot;!(expr)&quot;</code>,运算过程为对内部表达式 <code>expr</code> 进行逻辑 <strong>非的运算</strong>(NOT)</li>
<li><code>&quot;&amp;(expr1,expr2,...)&quot;</code>,运算过程为对 2 个或以上内部表达式 <code>expr1, expr2, ...</code> 进行逻辑 <strong>与的运算</strong>(AND)</li>
<li><code>&quot;|(expr1,expr2,...)&quot;</code>,运算过程为对 2 个或以上内部表达式 <code>expr1, expr2, ...</code> 进行逻辑 <strong>或的运算</strong>(OR)</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>expression = &quot;!(f)&quot;
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>expression = &quot;|(f,t)&quot;
<strong>输出:</strong>true
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>expression = &quot;&amp;(t,f)&quot;
<strong>输出:</strong>false
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>expression = &quot;|(&amp;(t,f,t),!(t))&quot;
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= expression.length &lt;= 20000</code></li>
<li><code>expression[i]</code><code>{&#39;(&#39;, &#39;)&#39;, &#39;&amp;&#39;, &#39;|&#39;, &#39;!&#39;, &#39;t&#39;, &#39;f&#39;, &#39;,&#39;}</code> 中的字符组成。</li>
<li><code>expression</code> 是以上述形式给出的有效表达式,表示一个布尔值。</li>
</ul>
<p>给你一个有效的 <a href="https://baike.baidu.com/item/IPv4" target="_blank">IPv4</a> 地址&nbsp;<code>address</code>,返回这个 IP 地址的无效化版本。</p>
<p>所谓无效化&nbsp;IP 地址,其实就是用&nbsp;<code>&quot;[.]&quot;</code>&nbsp;代替了每个 <code>&quot;.&quot;</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>address = &quot;1.1.1.1&quot;
<strong>输出:</strong>&quot;1[.]1[.]1[.]1&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>address = &quot;255.100.50.0&quot;
<strong>输出:</strong>&quot;255[.]100[.]50[.]0&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>给出的&nbsp;<code>address</code>&nbsp;是一个有效的 IPv4 地址</li>
</ul>
<p>这里有&nbsp;<code>n</code>&nbsp;个航班,它们分别从 <code>1</code><code>n</code> 进行编号。</p>
<p>有一份航班预订表&nbsp;<code>bookings</code> ,表中第&nbsp;<code>i</code>&nbsp;条预订记录&nbsp;<code>bookings[i] = [first<sub>i</sub>, last<sub>i</sub>, seats<sub>i</sub>]</code>&nbsp;意味着在从 <code>first<sub>i</sub></code>&nbsp;<code>last<sub>i</sub></code><strong>包含</strong> <code>first<sub>i</sub></code><code>last<sub>i</sub></code> )的 <strong>每个航班</strong> 上预订了 <code>seats<sub>i</sub></code>&nbsp;个座位。</p>
<p>请你返回一个长度为 <code>n</code> 的数组&nbsp;<code>answer</code>,里面的元素是每个航班预定的座位总数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5
<strong>输出:</strong>[10,55,45,25,25]
<strong>解释:</strong>
航班编号 1 2 3 4 5
预订记录 1 : 10 10
预订记录 2 : 20 20
预订记录 3 : 25 25 25 25
总座位数: 10 55 45 25 25
因此,answer = [10,55,45,25,25]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>bookings = [[1,2,10],[2,2,15]], n = 2
<strong>输出:</strong>[10,25]
<strong>解释:</strong>
航班编号 1 2
预订记录 1 : 10 10
预订记录 2 : 15
总座位数: 10 25
因此,answer = [10,25]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 2 * 10<sup>4</sup></code></li>
<li><code>1 &lt;= bookings.length &lt;= 2 * 10<sup>4</sup></code></li>
<li><code>bookings[i].length == 3</code></li>
<li><code>1 &lt;= first<sub>i</sub> &lt;= last<sub>i</sub> &lt;= n</code></li>
<li><code>1 &lt;= seats<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
</ul>
<p>给出二叉树的根节点&nbsp;<code>root</code>,树上每个节点都有一个不同的值。</p>
<p>如果节点值在&nbsp;<code>to_delete</code>&nbsp;中出现,我们就把该节点从树上删去,最后得到一个森林(一些不相交的树构成的集合)。</p>
<p>返回森林中的每棵树。你可以按任意顺序组织答案。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/07/05/screen-shot-2019-07-01-at-53836-pm.png" style="height: 150px; width: 237px;"></strong></p>
<pre><strong>输入:</strong>root = [1,2,3,4,5,6,7], to_delete = [3,5]
<strong>输出:</strong>[[1,2,null,4],[6],[7]]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的节点数最大为&nbsp;<code>1000</code></li>
<li>每个节点都有一个介于&nbsp;<code>1</code>&nbsp;<code>1000</code>&nbsp;之间的值,且各不相同。</li>
<li><code>to_delete.length &lt;= 1000</code></li>
<li><code>to_delete</code> 包含一些从&nbsp;<code>1</code>&nbsp;<code>1000</code>、各不相同的值。</li>
</ul>
<p>给定一个二叉树,找出其最小深度。</p>
<p>最小深度是从根节点到最近叶子节点的最短路径上的节点数量。</p>
<p><strong>说明:</strong>叶子节点是指没有子节点的节点。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg" style="width: 432px; height: 302px;" />
<pre>
<strong>输入:</strong>root = [3,9,20,null,null,15,7]
<strong>输出:</strong>2
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = [2,null,3,null,4,null,5,null,6]
<strong>输出:</strong>5
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点数的范围在 <code>[0, 10<sup>5</sup>]</code></li>
<li><code>-1000 <= Node.val <= 1000</code></li>
</ul>
<p><strong>有效括号字符串 </strong>定义:对于每个左括号,都能找到与之对应的右括号,反之亦然。详情参见题末「<strong>有效括号字符串</strong>」部分。</p>
<p><strong>嵌套深度</strong> <code>depth</code> 定义:即有效括号字符串嵌套的层数,<code>depth(A)</code> 表示有效括号字符串 <code>A</code> 的嵌套深度。详情参见题末「<strong>嵌套深度</strong>」部分。</p>
<p>有效括号字符串类型与对应的嵌套深度计算方法如下图所示:</p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/01/1111.png" style="height: 152px; width: 600px;"></p>
<p>&nbsp;</p>
<p>给你一个「有效括号字符串」 <code>seq</code>,请你将其分成两个不相交的有效括号字符串,<code>A</code>&nbsp;<code>B</code>,并使这两个字符串的深度最小。</p>
<ul>
<li>不相交:每个 <code>seq[i]</code> 只能分给 <code>A</code><code>B</code> 二者中的一个,不能既属于 <code>A</code> 也属于 <code>B</code></li>
<li><code>A</code><code>B</code> 中的元素在原字符串中可以不连续。</li>
<li><code>A.length + B.length = seq.length</code></li>
<li>深度最小:<code>max(depth(A), depth(B))</code>&nbsp;的可能取值最小。&nbsp;</li>
</ul>
<p>划分方案用一个长度为 <code>seq.length</code> 的答案数组 <code>answer</code> 表示,编码规则如下:</p>
<ul>
<li><code>answer[i] = 0</code><code>seq[i]</code> 分给 <code>A</code></li>
<li><code>answer[i] = 1</code><code>seq[i]</code> 分给 <code>B</code></li>
</ul>
<p>如果存在多个满足要求的答案,只需返回其中任意 <strong>一个 </strong>即可。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>seq = &quot;(()())&quot;
<strong>输出:</strong>[0,1,1,1,1,0]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>seq = &quot;()(())()&quot;
<strong>输出:</strong>[0,0,0,1,1,0,1,1]
<strong>解释:</strong>本示例答案不唯一。
按此输出 A = &quot;()()&quot;, B = &quot;()()&quot;, max(depth(A), depth(B)) = 1,它们的深度最小。
像 [1,1,1,0,0,1,1,1],也是正确结果,其中 A = &quot;()()()&quot;, B = &quot;()&quot;, max(depth(A), depth(B)) = 1 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;&nbsp;seq.size &lt;= 10000</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>有效括号字符串:</strong></p>
<pre>仅由&nbsp;<code>&quot;(&quot;</code>&nbsp;<code>&quot;)&quot;</code>&nbsp;构成的字符串,对于每个左括号,都能找到与之对应的右括号,反之亦然。
下述几种情况同样属于有效括号字符串:
1. 空字符串
2. 连接,可以记作&nbsp;<code>AB</code><code>A</code><code>B</code> 连接),其中&nbsp;<code>A</code>&nbsp;&nbsp;<code>B</code>&nbsp;都是有效括号字符串
3. 嵌套,可以记作&nbsp;<code>(A)</code>,其中&nbsp;<code>A</code>&nbsp;是有效括号字符串
</pre>
<p><strong>嵌套深度:</strong></p>
<pre>类似地,我们可以定义任意有效括号字符串 <code>s</code><strong>嵌套深度</strong>&nbsp;<code>depth(S)</code>
1.<code> s</code> 为空时,<code>depth(&quot;&quot;) = 0</code>
<code> 2. s</code><code>A</code><code>B</code> 连接时,<code>depth(A + B) = max(depth(A), depth(B))</code>,其中&nbsp;<code>A</code>&nbsp;<code>B</code>&nbsp;都是有效括号字符串
<code> 3. s</code> 为嵌套情况,<code>depth(&quot;(&quot; + A + &quot;)&quot;) = 1 + depth(A)</code>,其中 <code>A</code> 是有效括号字符串
例如:<code>&quot;&quot;</code><code>&quot;()()&quot;</code>,和&nbsp;<code>&quot;()(()())&quot;</code>&nbsp;都是有效括号字符串,嵌套深度分别为 0,1,2,而&nbsp;<code>&quot;)(&quot;</code>&nbsp;<code>&quot;(()&quot;</code>&nbsp;都不是有效括号字符串。
</pre>
<p>我们提供了一个类:</p>
<pre>
public class Foo {
  public void first() { print("first"); }
  public void second() { print("second"); }
  public void third() { print("third"); }
}</pre>
<p>三个不同的线程 A、B、C 将会共用一个 <code>Foo</code> 实例。</p>
<ul>
<li>一个将会调用 <code>first()</code> 方法</li>
<li>一个将会调用 <code>second()</code> 方法</li>
<li>还有一个将会调用 <code>third()</code> 方法</li>
</ul>
<p>请设计修改程序,以确保 <code>second()</code> 方法在 <code>first()</code> 方法之后被执行,<code>third()</code> 方法在 <code>second()</code> 方法之后被执行。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong> [1,2,3]
<strong>输出:</strong> "firstsecondthird"
<strong>解释:</strong>
有三个线程会被异步启动。
输入 [1,2,3] 表示线程 A 将会调用 first() 方法,线程 B 将会调用 second() 方法,线程 C 将会调用 third() 方法。
正确的输出是 "firstsecondthird"。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong> [1,3,2]
<strong>输出:</strong> "firstsecondthird"
<strong>解释:</strong>
输入 [1,3,2] 表示线程 A 将会调用 first() 方法,线程 B 将会调用 third() 方法,线程 C 将会调用 second() 方法。
正确的输出是 "firstsecondthird"。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>尽管输入中的数字似乎暗示了顺序,但是我们并不保证线程在操作系统中的调度顺序。</li>
<li>你看到的输入格式主要是为了确保测试的全面性。</li>
</ul>
<p>我们提供一个类:</p>
<pre>
class FooBar {
public void foo() {
&nbsp; &nbsp; for (int i = 0; i &lt; n; i++) {
&nbsp; &nbsp; &nbsp; print(&quot;foo&quot;);
&nbsp; }
}
public void bar() {
&nbsp; &nbsp; for (int i = 0; i &lt; n; i++) {
&nbsp; &nbsp; &nbsp; print(&quot;bar&quot;);
&nbsp; &nbsp; }
}
}
</pre>
<p>两个不同的线程将会共用一个 <code>FooBar</code>&nbsp;实例。其中一个线程将会调用&nbsp;<code>foo()</code>&nbsp;方法,另一个线程将会调用&nbsp;<code>bar()</code>&nbsp;方法。</p>
<p>请设计修改程序,以确保 &quot;foobar&quot; 被输出 n 次。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong> n = 1
<strong>输出:</strong> &quot;foobar&quot;
<strong>解释:</strong> 这里有两个线程被异步启动。其中一个调用 foo() 方法, 另一个调用 bar() 方法,&quot;foobar&quot; 将被输出一次。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong> n = 2
<strong>输出:</strong> &quot;foobarfoobar&quot;
<strong>解释:</strong> &quot;foobar&quot; 将被输出两次。
</pre>
<p>假设有这么一个类:</p>
<pre>class ZeroEvenOdd {
&nbsp; public ZeroEvenOdd(int n) { ... }&nbsp; // 构造函数
public void zero(printNumber) { ... } // 仅打印出 0
public void even(printNumber) { ... } // 仅打印出 偶数
public void odd(printNumber) { ... } // 仅打印出 奇数
}
</pre>
<p>相同的一个&nbsp;<code>ZeroEvenOdd</code>&nbsp;类实例将会传递给三个不同的线程:</p>
<ol>
<li>线程 A 将调用&nbsp;<code>zero()</code>,它只输出 0 。</li>
<li>线程 B 将调用&nbsp;<code>even()</code>,它只输出偶数。</li>
<li>线程 C 将调用&nbsp;<code>odd()</code>,它只输出奇数。</li>
</ol>
<p>每个线程都有一个&nbsp;<code>printNumber</code> 方法来输出一个整数。请修改给出的代码以输出整数序列&nbsp;<code>010203040506</code>... ,其中序列的长度必须为 2<em>n</em></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>&quot;0102&quot;
<strong>说明:</strong>三条线程异步执行,其中一个调用 zero(),另一个线程调用 even(),最后一个线程调用odd()。正确的输出为 &quot;0102&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 5
<strong>输出:</strong>&quot;0102030405&quot;
</pre>
<p>现在有两种线程,氧 <code>oxygen</code> 和氢 <code>hydrogen</code>,你的目标是组织这两种线程来产生水分子。</p>
<p>存在一个屏障(barrier)使得每个线程必须等候直到一个完整水分子能够被产生出来。</p>
<p>氢和氧线程会被分别给予 <code>releaseHydrogen</code><code>releaseOxygen</code> 方法来允许它们突破屏障。</p>
<p>这些线程应该三三成组突破屏障并能立即组合产生一个水分子。</p>
<p>你必须保证产生一个水分子所需线程的结合必须发生在下一个水分子产生之前。</p>
<p>换句话说:</p>
<ul>
<li>如果一个氧线程到达屏障时没有氢线程到达,它必须等候直到两个氢线程到达。</li>
<li>如果一个氢线程到达屏障时没有其它线程到达,它必须等候直到一个氧线程和另一个氢线程到达。</li>
</ul>
<p>书写满足这些限制条件的氢、氧线程同步代码。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入: </strong>&quot;HOH&quot;
<strong>输出: </strong>&quot;HHO&quot;
<strong>解释:</strong> &quot;HOH&quot;&quot;OHH&quot; 依然都是有效解。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入: </strong>&quot;OOHHHH&quot;
<strong>输出: </strong>&quot;HHOHHO&quot;
<strong>解释:</strong> &quot;HOHHHO&quot;, &quot;OHHHHO&quot;, &quot;HHOHOH&quot;, &quot;HOHHOH&quot;, &quot;OHHHOH&quot;, &quot;HHOOHH&quot;, &quot;HOHOHH&quot;&quot;OHHOHH&quot; 依然都是有效解。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>输入字符串的总长将会是 3<em>n</em>, 1 &le;&nbsp;<em>n</em>&nbsp;&le; 50;</li>
<li>输入字符串中的 &ldquo;H&rdquo; 总数将会是 2n 。</li>
<li>输入字符串中的 &ldquo;O&rdquo; 总数将会是 n 。</li>
</ul>
<p>给你二叉树的根节点 <code>root</code> 和一个表示目标和的整数 <code>targetSum</code> ,判断该树中是否存在 <strong>根节点到叶子节点</strong> 的路径,这条路径上所有节点值相加等于目标和 <code>targetSum</code></p>
<p><strong>叶子节点</strong> 是指没有子节点的节点。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg" style="width: 500px; height: 356px;" />
<pre>
<strong>输入:</strong>root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg" />
<pre>
<strong>输入:</strong>root = [1,2,3], targetSum = 5
<strong>输出:</strong>false
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [1,2], targetSum = 0
<strong>输出:</strong>false
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点的数目在范围 <code>[0, 5000]</code></li>
<li><code>-1000 <= Node.val <= 1000</code></li>
<li><code>-1000 <= targetSum <= 1000</code></li>
</ul>
<p>给你两个数组,<code>arr1</code> 和 <code>arr2</code></p>
<ul>
<li><code>arr2</code> 中的元素各不相同</li>
<li><code>arr2</code> 中的每个元素都出现在 <code>arr1</code> 中</li>
</ul>
<p><code>arr1</code> 中的元素进行排序,使 <code>arr1</code> 中项的相对顺序和 <code>arr2</code> 中的相对顺序相同。未在 <code>arr2</code> 中出现过的元素需要按照升序放在 <code>arr1</code> 的末尾。</p>
<p> </p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入:</strong>arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
<strong>输出:</strong>[2,2,2,1,4,3,3,9,6,7,19]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= arr1.length, arr2.length <= 1000</code></li>
<li><code>0 <= arr1[i], arr2[i] <= 1000</code></li>
<li><code>arr2</code> 中的元素 <code>arr2[i]</code> 各不相同</li>
<li><code>arr2</code> 中的每个元素 <code>arr2[i]</code> 都出现在 <code>arr1</code> 中</li>
</ul>
<p>给你一个有根节点的二叉树,找到它最深的叶节点的最近公共祖先。</p>
<p>回想一下:</p>
<ul>
<li><strong>叶节点</strong> 是二叉树中没有子节点的节点</li>
<li>树的根节点的 <strong>深度 </strong>为 <code>0</code>,如果某一节点的深度为 <code>d</code>,那它的子节点的深度就是 <code>d+1</code></li>
<li>如果我们假定 <code>A</code> 是一组节点 <code>S</code> 的 <strong>最近公共祖先</strong><code>S</code> 中的每个节点都在以 <code>A</code> 为根节点的子树中,且 <code>A</code> 的深度达到此条件下可能的最大值。</li>
</ul>
<p> </p>
<p>注意:本题与力扣 865 重复:<a href="https://leetcode-cn.com/problems/smallest-subtree-with-all-the-deepest-nodes/">https://leetcode-cn.com/problems/smallest-subtree-with-all-the-deepest-nodes/</a></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/01/sketch1.png" style="width: 600px; height: 510px;" />
<pre>
<strong>输入:</strong>root = [3,5,1,6,2,0,8,null,null,7,4]
<strong>输出:</strong>[2,7,4]
<strong>解释:</strong>
我们返回值为 2 的节点,在图中用黄色标记。
在图中用蓝色标记的是树的最深的节点。
注意,节点 6、0 和 8 也是叶节点,但是它们的深度是 2 ,而节点 7 和 4 的深度是 3 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = [1]
<strong>输出:</strong>[1]
<strong>解释:</strong>根节点是树中最深的节点,它是它本身的最近公共祖先。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [0,1,3,null,2]
<strong>输出:</strong>[2]
<strong>解释:</strong>树中最深的叶节点是 2 ,最近公共祖先是它自己。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>给你的树中将有 1 到 1000 个节点。</li>
<li>树中每个节点的值都在 1 到 1000 之间。</li>
<li>每个节点的值都是独一无二的。</li>
</ul>
<p>给你一份工作时间表&nbsp;<code>hours</code>,上面记录着某一位员工每天的工作小时数。</p>
<p>我们认为当员工一天中的工作小时数大于&nbsp;<code>8</code> 小时的时候,那么这一天就是「<strong>劳累的一天</strong>」。</p>
<p>所谓「表现良好的时间段」,意味在这段时间内,「劳累的天数」是严格<strong> 大于</strong>「不劳累的天数」。</p>
<p>请你返回「表现良好时间段」的最大长度。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>hours = [9,9,6,0,6,6,9]
<strong>输出:</strong>3
<strong>解释:</strong>最长的表现良好时间段是 [9,9,6]。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= hours.length &lt;= 10000</code></li>
<li><code>0 &lt;= hours[i] &lt;= 16</code></li>
</ul>
<p>作为项目经理,你规划了一份需求的技能清单 <code>req_skills</code>,并打算从备选人员名单 <code>people</code> 中选出些人组成一个「必要团队」( 编号为 <code>i</code> 的备选人员 <code>people[i]</code> 含有一份该备选人员掌握的技能列表)。</p>
<p>所谓「必要团队」,就是在这个团队中,对于所需求的技能列表 <code>req_skills</code> 中列出的每项技能,团队中至少有一名成员已经掌握。可以用每个人的编号来表示团队中的成员:</p>
<ul>
<li>例如,团队 <code>team = [0, 1, 3]</code> 表示掌握技能分别为 <code>people[0]</code><code>people[1]</code>,和 <code>people[3]</code> 的备选人员。</li>
</ul>
<p>请你返回 <strong>任一</strong> 规模最小的必要团队,团队成员用人员编号表示。你可以按 <strong>任意顺序</strong> 返回答案,题目数据保证答案存在。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>req_skills = ["java","nodejs","reactjs"], people = [["java"],["nodejs"],["nodejs","reactjs"]]
<strong>输出:</strong>[0,2]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>req_skills = ["algorithms","math","java","reactjs","csharp","aws"], people = [["algorithms","math","java"],["algorithms","math","reactjs"],["java","csharp","aws"],["reactjs","csharp"],["csharp","math"],["aws","java"]]
<strong>输出:</strong>[1,2]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= req_skills.length <= 16</code></li>
<li><code>1 <= req_skills[i].length <= 16</code></li>
<li><code>req_skills[i]</code> 由小写英文字母组成</li>
<li><code>req_skills</code> 中的所有字符串 <strong>互不相同</strong></li>
<li><code>1 <= people.length <= 60</code></li>
<li><code>0 <= people[i].length <= 16</code></li>
<li><code>1 <= people[i][j].length <= 16</code></li>
<li><code>people[i][j]</code> 由小写英文字母组成</li>
<li><code>people[i]</code> 中的所有字符串 <strong>互不相同</strong></li>
<li><code>people[i]</code> 中的每个技能是 <code>req_skills</code> 中的技能</li>
<li>题目数据保证「必要团队」一定存在</li>
</ul>
<p>给你一个由一些多米诺骨牌组成的列表&nbsp;<code>dominoes</code></p>
<p>如果其中某一张多米诺骨牌可以通过旋转 <code>0</code>&nbsp;度或 <code>180</code> 度得到另一张多米诺骨牌,我们就认为这两张牌是等价的。</p>
<p>形式上,<code>dominoes[i] = [a, b]</code>&nbsp;&nbsp;<code>dominoes[j] = [c, d]</code>&nbsp;等价的前提是&nbsp;<code>a==c</code>&nbsp;&nbsp;<code>b==d</code>,或是&nbsp;<code>a==d</code>&nbsp;<code>b==c</code></p>
<p>&nbsp;<code>0 &lt;= i &lt; j &lt; dominoes.length</code>&nbsp;的前提下,找出满足&nbsp;<code>dominoes[i]</code>&nbsp;<code>dominoes[j]</code>&nbsp;等价的骨牌对 <code>(i, j)</code> 的数量。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>dominoes = [[1,2],[2,1],[3,4],[5,6]]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= dominoes.length &lt;= 40000</code></li>
<li><code>1 &lt;= dominoes[i][j] &lt;= 9</code></li>
</ul>
<p>在一个有向图中,节点分别标记为&nbsp;<code>0, 1, ..., n-1</code>。这个图中的每条边不是红色就是蓝色,且存在自环或平行边。</p>
<p><code>red_edges</code>&nbsp;中的每一个&nbsp;<code>[i, j]</code>&nbsp;对表示从节点 <code>i</code> 到节点 <code>j</code> 的红色有向边。类似地,<code>blue_edges</code>&nbsp;中的每一个&nbsp;<code>[i, j]</code>&nbsp;对表示从节点 <code>i</code> 到节点 <code>j</code> 的蓝色有向边。</p>
<p>返回长度为 <code>n</code> 的数组&nbsp;<code>answer</code>,其中&nbsp;<code>answer[X]</code>&nbsp;是从节点&nbsp;<code>0</code>&nbsp;到节点&nbsp;<code>X</code>&nbsp;的红色边和蓝色边交替出现的最短路径的长度。如果不存在这样的路径,那么 <code>answer[x] = -1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 3, red_edges = [[0,1],[1,2]], blue_edges = []
<strong>输出:</strong>[0,1,-1]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 3, red_edges = [[0,1]], blue_edges = [[2,1]]
<strong>输出:</strong>[0,1,-1]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 3, red_edges = [[1,0]], blue_edges = [[2,1]]
<strong>输出:</strong>[0,-1,-1]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 3, red_edges = [[0,1]], blue_edges = [[1,2]]
<strong>输出:</strong>[0,1,2]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]]
<strong>输出:</strong>[0,1,1]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 100</code></li>
<li><code>red_edges.length &lt;= 400</code></li>
<li><code>blue_edges.length &lt;= 400</code></li>
<li><code>red_edges[i].length == blue_edges[i].length == 2</code></li>
<li><code>0 &lt;= red_edges[i][j], blue_edges[i][j] &lt; n</code></li>
</ul>
<p>给你一个正整数数组&nbsp;<code>arr</code>,考虑所有满足以下条件的二叉树:</p>
<ul>
<li>每个节点都有 0 个或是 2 个子节点。</li>
<li>数组&nbsp;<code>arr</code>&nbsp;中的值与树的中序遍历中每个叶节点的值一一对应。(知识回顾:如果一个节点有 0 个子节点,那么该节点为叶节点。)</li>
<li>每个非叶节点的值等于其左子树和右子树中叶节点的最大值的乘积。</li>
</ul>
<p>在所有这样的二叉树中,返回每个非叶节点的值的最小可能总和。这个和的值是一个&nbsp;32 位整数。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>arr = [6,2,4]
<strong>输出:</strong>32
<strong>解释:</strong>
有两种可能的树,第一种的非叶节点的总和为 36,第二种非叶节点的总和为 32。
24 24
/ \ / \
12 4 6 8
/ \ / \
6 2 2 4</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= arr.length &lt;= 40</code></li>
<li><code>1 &lt;= arr[i] &lt;= 15</code></li>
<li>答案保证是一个 32 位带符号整数,即小于&nbsp;<code>2^31</code></li>
</ul>
<p>给你二叉树的根节点 <code>root</code> 和一个整数目标和 <code>targetSum</code> ,找出所有 <strong>从根节点到叶子节点</strong> 路径总和等于给定目标和的路径。</p>
<p><strong>叶子节点</strong> 是指没有子节点的节点。</p>
<div class="original__bRMd">
<div>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsumii1.jpg" style="width: 500px; height: 356px;" />
<pre>
<strong>输入:</strong>root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
<strong>输出:</strong>[[5,4,11,2],[5,8,4,5]]
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg" style="width: 212px; height: 181px;" />
<pre>
<strong>输入:</strong>root = [1,2,3], targetSum = 5
<strong>输出:</strong>[]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [1,2], targetSum = 0
<strong>输出:</strong>[]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点总数在范围 <code>[0, 5000]</code></li>
<li><code>-1000 <= Node.val <= 1000</code></li>
<li><code>-1000 <= targetSum <= 1000</code></li>
</ul>
</div>
</div>
<p>给你两个长度相等的整数数组,返回下面表达式的最大值:</p>
<p><code>|arr1[i] - arr1[j]| + |arr2[i] - arr2[j]| + |i - j|</code></p>
<p>其中下标 <code>i</code><code>j</code> 满足&nbsp;<code>0 &lt;= i, j &lt; arr1.length</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,2,3,4], arr2 = [-1,4,5,6]
<strong>输出:</strong>13
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,-2,-5,0,10], arr2 = [0,-2,-1,-7,-4]
<strong>输出:</strong>20</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= arr1.length == arr2.length &lt;= 40000</code></li>
<li><code>-10^6 &lt;= arr1[i], arr2[i] &lt;= 10^6</code></li>
</ul>
<p>泰波那契序列&nbsp;T<sub>n</sub>&nbsp;定义如下:&nbsp;</p>
<p>T<sub>0</sub> = 0, T<sub>1</sub> = 1, T<sub>2</sub> = 1, 且在 n &gt;= 0&nbsp;的条件下 T<sub>n+3</sub> = T<sub>n</sub> + T<sub>n+1</sub> + T<sub>n+2</sub></p>
<p>给你整数&nbsp;<code>n</code>,请返回第 n 个泰波那契数&nbsp;T<sub>n </sub>的值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 4
<strong>输出:</strong>4
<strong>解释:</strong>
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 25
<strong>输出:</strong>1389537
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 &lt;= n &lt;= 37</code></li>
<li>答案保证是一个 32 位整数,即&nbsp;<code>answer &lt;= 2^31 - 1</code></li>
</ul>
<p>我们从一块字母板上的位置&nbsp;<code>(0, 0)</code>&nbsp;出发,该坐标对应的字符为&nbsp;<code>board[0][0]</code></p>
<p>在本题里,字母板为<code>board = [&quot;abcde&quot;, &quot;fghij&quot;, &quot;klmno&quot;, &quot;pqrst&quot;, &quot;uvwxy&quot;, &quot;z&quot;]</code>,如下所示。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/07/28/azboard.png" style="width: 300px;"></p>
<p>我们可以按下面的指令规则行动:</p>
<ul>
<li>如果方格存在,<code>&#39;U&#39;</code>&nbsp;意味着将我们的位置上移一行;</li>
<li>如果方格存在,<code>&#39;D&#39;</code>&nbsp;意味着将我们的位置下移一行;</li>
<li>如果方格存在,<code>&#39;L&#39;</code>&nbsp;意味着将我们的位置左移一列;</li>
<li>如果方格存在,<code>&#39;R&#39;</code>&nbsp;意味着将我们的位置右移一列;</li>
<li><code>&#39;!&#39;</code>&nbsp;会把在我们当前位置 <code>(r, c)</code> 的字符&nbsp;<code>board[r][c]</code>&nbsp;添加到答案中。</li>
</ul>
<p>(注意,字母板上只存在有字母的位置。)</p>
<p>返回指令序列,用最小的行动次数让答案和目标&nbsp;<code>target</code>&nbsp;相同。你可以返回任何达成目标的路径。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>target = &quot;leet&quot;
<strong>输出:</strong>&quot;DDR!UURRR!!DDD!&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>target = &quot;code&quot;
<strong>输出:</strong>&quot;RR!DDRR!UUL!R!&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= target.length &lt;= 100</code></li>
<li><code>target</code>&nbsp;仅含有小写英文字母。</li>
</ul>
<p>给你一个由若干 <code>0</code><code>1</code> 组成的二维网格&nbsp;<code>grid</code>,请你找出边界全部由 <code>1</code> 组成的最大 <strong>正方形</strong> 子网格,并返回该子网格中的元素数量。如果不存在,则返回 <code>0</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1,1],[1,0,1],[1,1,1]]
<strong>输出:</strong>9
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1,0,0]]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= grid.length &lt;= 100</code></li>
<li><code>1 &lt;= grid[0].length &lt;= 100</code></li>
<li><code>grid[i][j]</code>&nbsp;<code>0</code>&nbsp;&nbsp;<code>1</code></li>
</ul>
<p>亚历克斯和李继续他们的石子游戏。许多堆石子&nbsp;<strong>排成一行</strong>,每堆都有正整数颗石子&nbsp;<code>piles[i]</code>。游戏以谁手中的石子最多来决出胜负。</p>
<p>亚历克斯和李轮流进行,亚历克斯先开始。最初,<code>M = 1</code></p>
<p>在每个玩家的回合中,该玩家可以拿走剩下的&nbsp;<strong></strong>&nbsp;<code>X</code>&nbsp;堆的所有石子,其中&nbsp;<code>1 &lt;= X &lt;= 2M</code>。然后,令&nbsp;<code>M = max(M, X)</code></p>
<p>游戏一直持续到所有石子都被拿走。</p>
<p>假设亚历克斯和李都发挥出最佳水平,返回亚历克斯可以得到的最大数量的石头。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>piles = [2,7,9,4,4]
<strong>输出:</strong>10
<strong>解释:
</strong>如果亚历克斯在开始时拿走一堆石子,李拿走两堆,接着亚历克斯也拿走两堆。在这种情况下,亚历克斯可以拿到 2 + 4 + 4 = 10 颗石子。
如果亚历克斯在开始时拿走两堆石子,那么李就可以拿走剩下全部三堆石子。在这种情况下,亚历克斯可以拿到 2 + 7 = 9 颗石子。
所以我们返回更大的 10。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= piles.length &lt;= 100</code></li>
<li><code>1 &lt;= piles[i]&nbsp;&lt;= 10 ^ 4</code></li>
</ul>
<p>给你二叉树的根结点 <code>root</code> ,请你将它展开为一个单链表:</p>
<ul>
<li>展开后的单链表应该同样使用 <code>TreeNode</code> ,其中 <code>right</code> 子指针指向链表中下一个结点,而左子指针始终为 <code>null</code></li>
<li>展开后的单链表应该与二叉树 <a href="https://baike.baidu.com/item/%E5%85%88%E5%BA%8F%E9%81%8D%E5%8E%86/6442839?fr=aladdin" target="_blank"><strong>先序遍历</strong></a> 顺序相同。</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg" style="width: 500px; height: 226px;" />
<pre>
<strong>输入:</strong>root = [1,2,5,3,4,null,6]
<strong>输出:</strong>[1,null,2,null,3,null,4,null,5,null,6]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = []
<strong>输出:</strong>[]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [0]
<strong>输出:</strong>[0]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中结点数在范围 <code>[0, 2000]</code></li>
<li><code>-100 <= Node.val <= 100</code></li>
</ul>
<p> </p>
<p><strong>进阶:</strong>你可以使用原地算法(<code>O(1)</code> 额外空间)展开这棵树吗?</p>
<p>给定两个字符串 <code>text1</code> 和 <code>text2</code>,返回这两个字符串的最长 <strong>公共子序列</strong> 的长度。如果不存在 <strong>公共子序列</strong> ,返回 <code>0</code></p>
<p>一个字符串的 <strong>子序列</strong><em> </em>是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。</p>
<ul>
<li>例如,<code>"ace"</code><code>"abcde"</code> 的子序列,但 <code>"aec"</code> 不是 <code>"abcde"</code> 的子序列。</li>
</ul>
<p>两个字符串的 <strong>公共子序列</strong> 是这两个字符串所共同拥有的子序列。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>text1 = "abcde", text2 = "ace"
<strong>输出:</strong>3
<strong>解释:</strong>最长公共子序列是 "ace" ,它的长度为 3 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>text1 = "abc", text2 = "abc"
<strong>输出:</strong>3
<strong>解释:</strong>最长公共子序列是 "abc" ,它的长度为 3 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>text1 = "abc", text2 = "def"
<strong>输出:</strong>0
<strong>解释:</strong>两个字符串没有公共子序列,返回 0 。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= text1.length, text2.length <= 1000</code></li>
<li><code>text1</code> 和 <code>text2</code> 仅由小写英文字符组成。</li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code>,每次 <strong>操作</strong>&nbsp;会从中选择一个元素并 <strong>将该元素的值减少&nbsp;1</strong></p>
<p>如果符合下列情况之一,则数组&nbsp;<code>A</code>&nbsp;就是 <strong>锯齿数组</strong></p>
<ul>
<li>每个偶数索引对应的元素都大于相邻的元素,即&nbsp;<code>A[0] &gt; A[1] &lt; A[2] &gt; A[3] &lt; A[4] &gt; ...</code></li>
<li>或者,每个奇数索引对应的元素都大于相邻的元素,即&nbsp;<code>A[0] &lt; A[1] &gt; A[2] &lt; A[3] &gt; A[4] &lt; ...</code></li>
</ul>
<p>返回将数组&nbsp;<code>nums</code>&nbsp;转换为锯齿数组所需的最小操作次数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3]
<strong>输出:</strong>2
<strong>解释:</strong>我们可以把 2 递减到 0,或把 3 递减到 1。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [9,6,1,6,2]
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
</ul>
<p>有两位极客玩家参与了一场「二叉树着色」的游戏。游戏中,给出二叉树的根节点&nbsp;<code>root</code>,树上总共有 <code>n</code> 个节点,且 <code>n</code> 为奇数,其中每个节点上的值从&nbsp;<code>1</code>&nbsp;<code>n</code>&nbsp;各不相同。</p>
<p>&nbsp;</p>
<p>游戏从「一号」玩家开始(「一号」玩家为红色,「二号」玩家为蓝色),最开始时,</p>
<p>「一号」玩家从 <code>[1, n]</code>&nbsp;中取一个值&nbsp;<code>x</code><code>1 &lt;= x &lt;= n</code>);</p>
<p>「二号」玩家也从&nbsp;<code>[1, n]</code>&nbsp;中取一个值&nbsp;<code>y</code><code>1 &lt;= y &lt;= n</code>)且&nbsp;<code>y != x</code></p>
<p>「一号」玩家给值为&nbsp;<code>x</code>&nbsp;的节点染上红色,而「二号」玩家给值为&nbsp;<code>y</code>&nbsp;的节点染上蓝色。</p>
<p>&nbsp;</p>
<p>之后两位玩家轮流进行操作,每一回合,玩家选择一个他之前涂好颜色的节点,将所选节点一个 <strong>未着色 </strong>的邻节点(即左右子节点、或父节点)进行染色。</p>
<p>如果当前玩家无法找到这样的节点来染色时,他的回合就会被跳过。</p>
<p>若两个玩家都没有可以染色的节点时,游戏结束。着色节点最多的那位玩家获得胜利 ✌️。</p>
<p>&nbsp;</p>
<p>现在,假设你是「二号」玩家,根据所给出的输入,假如存在一个&nbsp;<code>y</code>&nbsp;值可以确保你赢得这场游戏,则返回&nbsp;<code>true</code>;若无法获胜,就请返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/08/04/1480-binary-tree-coloring-game.png" style="height: 186px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3
<strong>输出:</strong>True
<strong>解释:</strong>第二个玩家可以选择值为 2 的节点。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>二叉树的根节点为&nbsp;<code>root</code>,树上由 <code>n</code> 个节点,节点上的值从 <code>1</code><code>n</code> 各不相同。</li>
<li><code>n</code> 为奇数。</li>
<li><code>1 &lt;= x &lt;= n&nbsp;&lt;= 100</code></li>
</ul>
<p>实现支持下列接口的「快照数组」-&nbsp;SnapshotArray:</p>
<ul>
<li><code>SnapshotArray(int length)</code>&nbsp;- 初始化一个与指定长度相等的 类数组 的数据结构。<strong>初始时,每个元素都等于</strong><strong>&nbsp;0</strong></li>
<li><code>void set(index, val)</code>&nbsp;- 会将指定索引&nbsp;<code>index</code>&nbsp;处的元素设置为&nbsp;<code>val</code></li>
<li><code>int snap()</code>&nbsp;- 获取该数组的快照,并返回快照的编号&nbsp;<code>snap_id</code>(快照号是调用&nbsp;<code>snap()</code>&nbsp;的总次数减去&nbsp;<code>1</code>)。</li>
<li><code>int get(index, snap_id)</code>&nbsp;- 根据指定的&nbsp;<code>snap_id</code>&nbsp;选择快照,并返回该快照指定索引 <code>index</code>&nbsp;的值。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>[&quot;SnapshotArray&quot;,&quot;set&quot;,&quot;snap&quot;,&quot;set&quot;,&quot;get&quot;]
[[3],[0,5],[],[0,6],[0,0]]
<strong>输出:</strong>[null,null,0,null,5]
<strong>解释:
</strong>SnapshotArray snapshotArr = new SnapshotArray(3); // 初始化一个长度为 3 的快照数组
snapshotArr.set(0,5); // 令 array[0] = 5
snapshotArr.snap(); // 获取快照,返回 snap_id = 0
snapshotArr.set(0,6);
snapshotArr.get(0,0); // 获取 snap_id = 0 的快照中 array[0] 的值,返回 5</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= length&nbsp;&lt;= 50000</code></li>
<li>题目最多进行<code>50000</code><code>set</code><code>snap</code>,和&nbsp;<code>get</code>的调用 。</li>
<li><code>0 &lt;= index&nbsp;&lt;&nbsp;length</code></li>
<li><code>0 &lt;=&nbsp;snap_id &lt;&nbsp;</code>我们调用&nbsp;<code>snap()</code>&nbsp;的总次数</li>
<li><code>0 &lt;=&nbsp;val &lt;= 10^9</code></li>
</ul>
<p>段式回文 其实与 一般回文 类似,只不过是最小的单位是 一段字符&nbsp;而不是 单个字母。</p>
<p>举个例子,对于一般回文 &quot;<code>abcba</code>&quot; 是回文,而 &quot;<code>volvo</code>&quot; 不是,但如果我们把&nbsp;&quot;<code>volvo</code>&quot; 分为 &quot;<code>vo</code>&quot;&quot;<code>l</code>&quot;&quot;<code>vo</code>&quot; 三段,则可以认为 &ldquo;<code>(vo)(l)(vo)</code>&rdquo; 是段式回文(分为 3 段)。</p>
<p>&nbsp;</p>
<p>给你一个字符串&nbsp;<code>text</code>,在确保它满足段式回文的前提下,请你返回 <strong></strong>&nbsp;<strong>最大数量</strong>&nbsp;<code>k</code></p>
<p>如果段的最大数量为&nbsp;<code>k</code>,那么存在满足以下条件的&nbsp;<code>a_1, a_2, ..., a_k</code></p>
<ul>
<li>每个&nbsp;<code>a_i</code>&nbsp;都是一个非空字符串;</li>
<li>将这些字符串首位相连的结果&nbsp;<code>a_1 + a_2 + ... + a_k</code>&nbsp;和原始字符串&nbsp;<code>text</code>&nbsp;相同;</li>
<li>对于所有<code>1 &lt;= i &lt;= k</code>,都有&nbsp;<code>a_i = a_{k+1 - i}</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>text = &quot;ghiabcdefhelloadamhelloabcdefghi&quot;
<strong>输出:</strong>7
<strong>解释:</strong>我们可以把字符串拆分成 &quot;(ghi)(abcdef)(hello)(adam)(hello)(abcdef)(ghi)&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>text = &quot;merchant&quot;
<strong>输出:</strong>1
<strong>解释:</strong>我们可以把字符串拆分成 &quot;(merchant)&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>text = &quot;antaprezatepzapreanta&quot;
<strong>输出:</strong>11
<strong>解释:</strong>我们可以把字符串拆分成 &quot;(a)(nt)(a)(pre)(za)(tpe)(za)(pre)(a)(nt)(a)&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>text = &quot;aaa&quot;
<strong>输出:</strong>3
<strong>解释:</strong>我们可以把字符串拆分成 &quot;(a)(a)(a)&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>text</code>&nbsp;仅由小写英文字符组成。</li>
<li><code>1 &lt;= text.length &lt;= 1000</code></li>
</ul>
<p>给定一个字符串 <code>s</code><strong> </strong>和一个字符串 <code>t</code> ,计算在 <code>s</code> 的子序列中 <code>t</code> 出现的个数。</p>
<p>字符串的一个 <strong>子序列</strong> 是指,通过删除一些(也可以不删除)字符且不干扰剩余字符相对位置所组成的新字符串。(例如,<code>"ACE"</code> 是 <code>"ABCDE"</code> 的一个子序列,而 <code>"AEC"</code> 不是)</p>
<p>题目数据保证答案符合 32 位带符号整数范围。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "rabbbit", t = "rabbit"<code>
<strong>输出</strong></code><strong></strong><code>3
</code><strong>解释:</strong>
如下图所示, 有 3 种可以从 s 中得到 <code>"rabbit" 的方案</code>
<code><strong><u>rabb</u></strong>b<strong><u>it</u></strong></code>
<code><strong><u>ra</u></strong>b<strong><u>bbit</u></strong></code>
<code><strong><u>rab</u></strong>b<strong><u>bit</u></strong></code></pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "babgbag", t = "bag"
<code><strong>输出</strong></code><strong></strong><code>5
</code><strong>解释:</strong>
如下图所示, 有 5 种可以从 s 中得到 <code>"bag" 的方案</code>
<code><strong><u>ba</u></strong>b<u><strong>g</strong></u>bag</code>
<code><strong><u>ba</u></strong>bgba<strong><u>g</u></strong></code>
<code><u><strong>b</strong></u>abgb<strong><u>ag</u></strong></code>
<code>ba<u><strong>b</strong></u>gb<u><strong>ag</strong></u></code>
<code>babg<strong><u>bag</u></strong></code>
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 <= s.length, t.length <= 1000</code></li>
<li><code>s</code><code>t</code> 由英文字母组成</li>
</ul>
<p>给你一个按 <code>YYYY-MM-DD</code> 格式表示日期的字符串&nbsp;<code>date</code>,请你计算并返回该日期是当年的第几天。</p>
<p>通常情况下,我们认为 1 月 1 日是每年的第 1 天,1 月 2 日是每年的第 2 天,依此类推。每个月的天数与现行公元纪年法(格里高利历)一致。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>date = &quot;2019-01-09&quot;
<strong>输出:</strong>9
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>date = &quot;2019-02-10&quot;
<strong>输出:</strong>41
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>date = &quot;2003-03-01&quot;
<strong>输出:</strong>60
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>date = &quot;2004-03-01&quot;
<strong>输出:</strong>61</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>date.length == 10</code></li>
<li><code>date[4] == date[7] == &#39;-&#39;</code>,其他的&nbsp;<code>date[i]</code>&nbsp;都是数字。</li>
<li><code>date</code> 表示的范围从 1900 年 1 月 1 日至 2019 年 12 月 31 日。</li>
</ul>
<p>这里有&nbsp;<code>d</code>&nbsp;个一样的骰子,每个骰子上都有&nbsp;<code>f</code>&nbsp;个面,分别标号为&nbsp;<code>1, 2, ..., f</code></p>
<p>我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和。</p>
<p>如果需要掷出的总点数为&nbsp;<code>target</code>,请你计算出有多少种不同的组合情况(所有的组合情况总共有 <code>f^d</code> 种),<strong>&nbsp;<code>10^9 + 7</code></strong>&nbsp;后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>d = 1, f = 6, target = 3
<strong>输出:</strong>1
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>d = 2, f = 6, target = 7
<strong>输出:</strong>6
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>d = 2, f = 5, target = 10
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>d = 1, f = 2, target = 3
<strong>输出:</strong>0
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>d = 30, f = 30, target = 500
<strong>输出:</strong>222616187</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= d, f &lt;= 30</code></li>
<li><code>1 &lt;= target &lt;= 1000</code></li>
</ul>
<p>如果字符串中的所有字符都相同,那么这个字符串是单字符重复的字符串。</p>
<p>给你一个字符串&nbsp;<code>text</code>,你只能交换其中两个字符一次或者什么都不做,然后得到一些单字符重复的子串。返回其中最长的子串的长度。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>text = &quot;ababa&quot;
<strong>输出:</strong>3
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>text = &quot;aaabaaa&quot;
<strong>输出:</strong>6
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>text = &quot;aaabbaaa&quot;
<strong>输出:</strong>4
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>text = &quot;aaaaa&quot;
<strong>输出:</strong>5
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>text = &quot;abcdef&quot;
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= text.length &lt;= 20000</code></li>
<li><code>text</code> 仅由小写英文字母组成。</li>
</ul>
<p>实现一个&nbsp;<code>MajorityChecker</code>&nbsp;的类,它应该具有下述几个 API:</p>
<ul>
<li><code>MajorityChecker(int[] arr)</code>&nbsp;会用给定的数组 <code>arr</code>&nbsp;来构造一个 <code>MajorityChecker</code> 的实例。</li>
<li><code>int query(int left, int right, int threshold)</code>&nbsp;有这么几个参数:
<ul>
<li><code>0 &lt;= left&nbsp;&lt;= right&nbsp;&lt; arr.length</code> 表示数组&nbsp;<code>arr</code>&nbsp;的子数组的长度。</li>
<li><code>2 * threshold &gt; right - left + 1</code>,也就是说阈值 <code>threshold</code>&nbsp;始终比子序列长度的一半还要大。</li>
</ul>
</li>
</ul>
<p>每次查询&nbsp;<code>query(...)</code>&nbsp;会返回在&nbsp;<code>arr[left], arr[left+1], ..., arr[right]</code>&nbsp;中至少出现阈值次数&nbsp;<code>threshold</code>&nbsp;的元素,如果不存在这样的元素,就返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre>MajorityChecker majorityChecker = new MajorityChecker([1,1,2,2,1,1]);
majorityChecker.query(0,5,4); // 返回 1
majorityChecker.query(0,3,3); // 返回 -1
majorityChecker.query(2,3,2); // 返回 2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;=&nbsp;20000</code></li>
<li><code>1 &lt;= arr[i]&nbsp;&lt;=&nbsp;20000</code></li>
<li>对于每次查询,<code>0 &lt;= left &lt;= right &lt; len(arr)</code></li>
<li>对于每次查询,<code>2 * threshold &gt; right - left + 1</code></li>
<li>查询次数最多为 <code>10000</code></li>
</ul>
<p>给你一份『词汇表』(字符串数组)&nbsp;<code>words</code>&nbsp;和一张『字母表』(字符串)&nbsp;<code>chars</code></p>
<p>假如你可以用&nbsp;<code>chars</code>&nbsp;中的『字母』(字符)拼写出 <code>words</code>&nbsp;中的某个『单词』(字符串),那么我们就认为你掌握了这个单词。</p>
<p>注意:每次拼写(指拼写词汇表中的一个单词)时,<code>chars</code> 中的每个字母都只能用一次。</p>
<p>返回词汇表&nbsp;<code>words</code>&nbsp;中你掌握的所有单词的 <strong>长度之和</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>words = [&quot;cat&quot;,&quot;bt&quot;,&quot;hat&quot;,&quot;tree&quot;], chars = &quot;atach&quot;
<strong>输出:</strong>6
<strong>解释: </strong>
可以形成字符串 &quot;cat&quot;&quot;hat&quot;,所以答案是 3 + 3 = 6。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>words = [&quot;hello&quot;,&quot;world&quot;,&quot;leetcode&quot;], chars = &quot;welldonehoneyr&quot;
<strong>输出:</strong>10
<strong>解释:</strong>
可以形成字符串 &quot;hello&quot;&quot;world&quot;,所以答案是 5 + 5 = 10。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= words.length &lt;= 1000</code></li>
<li><code>1 &lt;= words[i].length, chars.length&nbsp;&lt;= 100</code></li>
<li>所有字符串中都仅包含小写英文字母</li>
</ol>
<p>给你一个二叉树的根节点&nbsp;<code>root</code>。设根节点位于二叉树的第 <code>1</code> 层,而根节点的子节点位于第 <code>2</code> 层,依此类推。</p>
<p>请你找出层内元素之和 <strong>最大</strong> 的那几层(可能只有一层)的层号,并返回其中&nbsp;<strong>最小</strong> 的那个。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/08/17/capture.jpeg" style="height: 175px; width: 200px;"></strong></p>
<pre><strong>输入:</strong>root = [1,7,0,7,-8,null,null]
<strong>输出:</strong>2
<strong>解释:</strong>
第 1 层各元素之和为 1,
第 2 层各元素之和为 7 + 0 = 7,
第 3 层各元素之和为 7 + -8 = -1,
所以我们返回第 2 层的层号,它的层内元素之和最大。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>root = [989,null,10250,98693,-89388,null,null,null,-32127]
<strong>输出:</strong>2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的节点数介于&nbsp;<code>1</code>&nbsp;&nbsp;<code>10^4</code>&nbsp;之间</li>
<li><code>-10^5 &lt;= node.val &lt;= 10^5</code></li>
</ul>
<p>你现在手里有一份大小为&nbsp;N x N 的 网格 <code>grid</code>,上面的每个 单元格 都用&nbsp;<code>0</code>&nbsp;&nbsp;<code>1</code>&nbsp;标记好了。其中&nbsp;<code>0</code>&nbsp;代表海洋,<code>1</code>&nbsp;代表陆地,请你找出一个海洋单元格,这个海洋单元格到离它最近的陆地单元格的距离是最大的。</p>
<p>我们这里说的距离是「曼哈顿距离」(&nbsp;Manhattan Distance):<code>(x0, y0)</code>&nbsp;<code>(x1, y1)</code>&nbsp;这两个单元格之间的距离是&nbsp;<code>|x0 - x1| + |y0 - y1|</code>&nbsp;</p>
<p>如果网格上只有陆地或者海洋,请返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/08/17/1336_ex1.jpeg" style="height: 87px; width: 185px;"></strong></p>
<pre><strong>输入:</strong>[[1,0,1],[0,0,0],[1,0,1]]
<strong>输出:</strong>2
<strong>解释: </strong>
海洋单元格 (1, 1) 和所有陆地单元格之间的距离都达到最大,最大距离为 2。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/08/17/1336_ex2.jpeg" style="height: 87px; width: 184px;"></strong></p>
<pre><strong>输入:</strong>[[1,0,0],[0,0,0],[0,0,0]]
<strong>输出:</strong>4
<strong>解释: </strong>
海洋单元格 (2, 2) 和所有陆地单元格之间的距离都达到最大,最大距离为 4。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= grid.length == grid[0].length&nbsp;&lt;= 100</code></li>
<li><code>grid[i][j]</code>&nbsp;不是&nbsp;<code>0</code>&nbsp;就是&nbsp;<code>1</code></li>
</ol>
<p>给你一个字符串&nbsp;<code>s</code>,找出它的所有子串并按字典序排列,返回排在最后的那个子串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>&quot;abab&quot;
<strong>输出:</strong>&quot;bab&quot;
<strong>解释:</strong>我们可以找出 7 个子串 [&quot;a&quot;, &quot;ab&quot;, &quot;aba&quot;, &quot;abab&quot;, &quot;b&quot;, &quot;ba&quot;, &quot;bab&quot;]。按字典序排在最后的子串是 &quot;bab&quot;
</pre>
<p><strong>示例&nbsp;2:</strong></p>
<pre><strong>输入:</strong>&quot;leetcode&quot;
<strong>输出:</strong>&quot;tcode&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li><code>1 &lt;= s.length &lt;= 4 * 10^5</code></li>
<li>s 仅含有小写英文字符。</li>
</ol>
<p>如果出现下述两种情况,交易 <strong>可能无效</strong></p>
<ul>
<li>交易金额超过 &yen;1000</li>
<li>或者,它和另一个城市中同名的另一笔交易相隔不超过 60 分钟(包含 60 分钟整)</li>
</ul>
<p>每个交易字符串&nbsp;<code>transactions[i]</code>&nbsp;由一些用逗号分隔的值组成,这些值分别表示交易的名称,时间(以分钟计),金额以及城市。</p>
<p>给你一份交易清单&nbsp;<code>transactions</code>,返回可能无效的交易列表。你可以按任何顺序返回答案。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>transactions = [&quot;alice,20,800,mtv&quot;,&quot;alice,50,100,beijing&quot;]
<strong>输出:</strong>[&quot;alice,20,800,mtv&quot;,&quot;alice,50,100,beijing&quot;]
<strong>解释:</strong>第一笔交易是无效的,因为第二笔交易和它间隔不超过 60 分钟、名称相同且发生在不同的城市。同样,第二笔交易也是无效的。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>transactions = [&quot;alice,20,800,mtv&quot;,&quot;alice,50,1200,mtv&quot;]
<strong>输出:</strong>[&quot;alice,50,1200,mtv&quot;]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>transactions = [&quot;alice,20,800,mtv&quot;,&quot;bob,50,1200,mtv&quot;]
<strong>输出:</strong>[&quot;bob,50,1200,mtv&quot;]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>transactions.length &lt;= 1000</code></li>
<li>每笔交易&nbsp;<code>transactions[i]</code>&nbsp;&nbsp;<code>&quot;{name},{time},{amount},{city}&quot;</code>&nbsp;的格式进行记录</li>
<li>每个交易名称&nbsp;<code>{name}</code>&nbsp;和城市&nbsp;<code>{city}</code>&nbsp;都由小写英文字母组成,长度在&nbsp;<code>1</code>&nbsp;&nbsp;<code>10</code>&nbsp;之间</li>
<li>每个交易时间&nbsp;<code>{time}</code>&nbsp;由一些数字组成,表示一个&nbsp;<code>0</code>&nbsp;&nbsp;<code>1000</code>&nbsp;之间的整数</li>
<li>每笔交易金额&nbsp;<code>{amount}</code>&nbsp;由一些数字组成,表示一个&nbsp;<code>0</code>&nbsp;<code>2000</code>&nbsp;之间的整数</li>
</ul>
<p>定义一个函数 <code>f(s)</code>,统计 <code>s</code>  中<strong>(按字典序比较)最小字母的出现频次</strong> ,其中 <code>s</code> 是一个非空字符串。</p>
<p>例如,若 <code>s = "dcce"</code>,那么 <code>f(s) = 2</code>,因为字典序最小字母是 <code>"c"</code>,它出现了 2 次。</p>
<p>现在,给你两个字符串数组待查表 <code>queries</code> 和词汇表 <code>words</code> 。对于每次查询 <code>queries[i]</code> ,需统计 <code>words</code> 中满足 <code>f(queries[i])</code> < <code>f(W)</code> 的<strong> 词的数目</strong><code>W</code> 表示词汇表 <code>words</code> 中的每个词。</p>
<p>请你返回一个整数数组 <code>answer</code> 作为答案,其中每个 <code>answer[i]</code> 是第 <code>i</code> 次查询的结果。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>queries = ["cbd"], words = ["zaaaz"]
<strong>输出:</strong>[1]
<strong>解释:</strong>查询 f("cbd") = 1,而 f("zaaaz") = 3 所以 f("cbd") < f("zaaaz")。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
<strong>输出:</strong>[1,2]
<strong>解释:</strong>第一个查询 f("bbb") < f("aaaa"),第二个查询 f("aaa") f("aaaa") > f("cc")。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= queries.length <= 2000</code></li>
<li><code>1 <= words.length <= 2000</code></li>
<li><code>1 <= queries[i].length, words[i].length <= 10</code></li>
<li><code>queries[i][j]</code><code>words[i][j]</code> 都由小写英文字母组成</li>
</ul>
<p>给定一个二叉树</p>
<pre>
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}</pre>
<p>填充它的每个 next 指针,让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点,则将 next 指针设置为 <code>NULL</code></p>
<p>初始状态下,所有 next 指针都被设置为 <code>NULL</code></p>
<p> </p>
<p><strong>进阶:</strong></p>
<ul>
<li>你只能使用常量级额外空间。</li>
<li>使用递归解题也符合要求,本题中递归程序占用的栈空间不算做额外的空间复杂度。</li>
</ul>
<p> </p>
<p><strong>示例:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/02/15/117_sample.png" style="height: 218px; width: 640px;" /></p>
<pre>
<strong>输入</strong>:root = [1,2,3,4,5,null,7]
<strong>输出:</strong>[1,#,2,3,#,4,5,7,#]
<strong>解释:</strong>给定二叉树如图 A 所示,你的函数应该填充它的每个 next 指针,以指向其下一个右侧节点,如图 B 所示。序列化输出按层序遍历顺序(由 next 指针连接),'#' 表示每层的末尾。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中的节点数小于 <code>6000</code></li>
<li><code>-100 <= node.val <= 100</code></li>
</ul>
<p> </p>
<ul>
</ul>
<p>给你一个链表的头节点&nbsp;<code>head</code>,请你编写代码,反复删去链表中由 <strong>总和</strong>&nbsp;值为 <code>0</code> 的连续节点组成的序列,直到不存在这样的序列为止。</p>
<p>删除完毕后,请你返回最终结果链表的头节点。</p>
<p>&nbsp;</p>
<p>你可以返回任何满足题目要求的答案。</p>
<p>(注意,下面示例中的所有序列,都是对&nbsp;<code>ListNode</code>&nbsp;对象序列化的表示。)</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>head = [1,2,-3,3,1]
<strong>输出:</strong>[3,1]
<strong>提示:</strong>答案 [1,2,1] 也是正确的。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>head = [1,2,3,-3,4]
<strong>输出:</strong>[1,2,4]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>head = [1,2,3,-3,-2]
<strong>输出:</strong>[1]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>给你的链表中可能有 <code>1</code>&nbsp;<code>1000</code>&nbsp;个节点。</li>
<li>对于链表中的每个节点,节点的值:<code>-1000 &lt;= node.val &lt;= 1000</code>.</li>
</ul>
<p>我们把无限数量 &infin; 的栈排成一行,按从左到右的次序从 0 开始编号。每个栈的的最大容量&nbsp;<code>capacity</code> 都相同。</p>
<p>实现一个叫「餐盘」的类&nbsp;<code>DinnerPlates</code></p>
<ul>
<li><code>DinnerPlates(int capacity)</code>&nbsp;- 给出栈的最大容量&nbsp;<code>capacity</code></li>
<li><code>void push(int val)</code>&nbsp;- 将给出的正整数&nbsp;<code>val</code>&nbsp;推入&nbsp;<strong>从左往右第一个&nbsp;</strong>没有满的栈。</li>
<li><code>int pop()</code>&nbsp;- 返回&nbsp;<strong>从右往左第一个&nbsp;</strong>非空栈顶部的值,并将其从栈中删除;如果所有的栈都是空的,请返回&nbsp;<code>-1</code></li>
<li><code>int popAtStack(int index)</code>&nbsp;- 返回编号&nbsp;<code>index</code>&nbsp;的栈顶部的值,并将其从栈中删除;如果编号&nbsp;<code>index</code>&nbsp;的栈是空的,请返回 <code>-1</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入: </strong>
[&quot;DinnerPlates&quot;,&quot;push&quot;,&quot;push&quot;,&quot;push&quot;,&quot;push&quot;,&quot;push&quot;,&quot;popAtStack&quot;,&quot;push&quot;,&quot;push&quot;,&quot;popAtStack&quot;,&quot;popAtStack&quot;,&quot;pop&quot;,&quot;pop&quot;,&quot;pop&quot;,&quot;pop&quot;,&quot;pop&quot;]
[[2],[1],[2],[3],[4],[5],[0],[20],[21],[0],[2],[],[],[],[],[]]
<strong>输出:</strong>
[null,null,null,null,null,null,2,null,null,20,21,5,4,3,1,-1]
<strong>解释:</strong>
DinnerPlates D = DinnerPlates(2); // 初始化,栈最大容量 capacity = 2
D.push(1);
D.push(2);
D.push(3);
D.push(4);
D.push(5); // 栈的现状为: 2 &nbsp;4
&nbsp; 1 &nbsp;3 &nbsp;5
﹈ ﹈ ﹈
D.popAtStack(0); // 返回 2。栈的现状为: &nbsp;4
&nbsp; 1 &nbsp;3 &nbsp;5
﹈ ﹈ ﹈
D.push(20); // 栈的现状为: 20 4
&nbsp; 1 &nbsp;3 &nbsp;5
﹈ ﹈ ﹈
D.push(21); // 栈的现状为: 20 4 21
&nbsp; 1 &nbsp;3 &nbsp;5
﹈ ﹈ ﹈
D.popAtStack(0); // 返回 20。栈的现状为: 4 21
&nbsp; 1 &nbsp;3 &nbsp;5
﹈ ﹈ ﹈
D.popAtStack(2); // 返回 21。栈的现状为: 4
&nbsp; 1 &nbsp;3 &nbsp;5
﹈ ﹈ ﹈
D.pop() // 返回 5。栈的现状为: 4
&nbsp; 1 &nbsp;3
﹈ ﹈
D.pop() // 返回 4。栈的现状为: 1 3
﹈ ﹈
D.pop() // 返回 3。栈的现状为: 1
D.pop() // 返回 1。现在没有栈。
D.pop() // 返回 -1。仍然没有栈。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= capacity&nbsp;&lt;= 20000</code></li>
<li><code>1 &lt;= val&nbsp;&lt;= 20000</code></li>
<li><code>0 &lt;= index&nbsp;&lt;= 100000</code></li>
<li>最多会对&nbsp;<code>push</code><code>pop</code>,和&nbsp;<code>popAtStack</code>&nbsp;进行 <code>200000</code> 次调用。</li>
</ul>
<p>请你帮忙给从 <code>1</code><code>n</code>&nbsp;的数设计排列方案,使得所有的「质数」都应该被放在「质数索引」(索引从 1 开始)上;你需要返回可能的方案总数。</p>
<p>让我们一起来回顾一下「质数」:质数一定是大于 1 的,并且不能用两个小于它的正整数的乘积来表示。</p>
<p>由于答案可能会很大,所以请你返回答案 <strong>模 mod&nbsp;<code>10^9 + 7</code></strong>&nbsp;之后的结果即可。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 5
<strong>输出:</strong>12
<strong>解释:</strong>举个例子,[1,2,5,4,3] 是一个有效的排列,但 [5,2,3,4,1] 不是,因为在第二种情况里质数 5 被错误地放在索引为 1 的位置上。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 100
<strong>输出:</strong>682289015
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 100</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>,请你对&nbsp;<code>s</code>&nbsp;的子串进行检测。</p>
<p>每次检测,待检子串都可以表示为&nbsp;<code>queries[i] = [left, right, k]</code>。我们可以 <strong>重新排列</strong> 子串&nbsp;<code>s[left], ..., s[right]</code>,并从中选择 <strong>最多</strong> <code>k</code>&nbsp;项替换成任何小写英文字母。&nbsp;</p>
<p>如果在上述检测过程中,子串可以变成回文形式的字符串,那么检测结果为&nbsp;<code>true</code>,否则结果为&nbsp;<code>false</code></p>
<p>返回答案数组&nbsp;<code>answer[]</code>,其中&nbsp;<code>answer[i]</code>&nbsp;是第&nbsp;<code>i</code>&nbsp;个待检子串&nbsp;<code>queries[i]</code>&nbsp;的检测结果。</p>
<p>注意:在替换时,子串中的每个字母都必须作为 <strong>独立的</strong> 项进行计数,也就是说,如果&nbsp;<code>s[left..right] = &quot;aaa&quot;</code>&nbsp;&nbsp;<code>k = 2</code>,我们只能替换其中的两个字母。(另外,任何检测都不会修改原始字符串 <code>s</code>,可以认为每次检测都是独立的)</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>s = &quot;abcda&quot;, queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
<strong>输出:</strong>[true,false,false,true,true]
<strong>解释:</strong>
queries[0] : 子串 = &quot;d&quot;,回文。
queries[1] :&nbsp;子串 = &quot;bc&quot;,不是回文。
queries[2] :&nbsp;子串 = &quot;abcd&quot;,只替换 1 个字符是变不成回文串的。
queries[3] :&nbsp;子串 = &quot;abcd&quot;,可以变成回文的 &quot;abba&quot;。 也可以变成 &quot;baab&quot;,先重新排序变成 &quot;bacd&quot;,然后把 &quot;cd&quot; 替换为 &quot;ab&quot;
queries[4] :&nbsp;子串 = &quot;abcda&quot;,可以变成回文的 &quot;abcba&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length,&nbsp;queries.length&nbsp;&lt;= 10^5</code></li>
<li><code>0 &lt;= queries[i][0] &lt;= queries[i][1] &lt;&nbsp;s.length</code></li>
<li><code>0 &lt;= queries[i][2] &lt;= s.length</code></li>
<li><code>s</code> 中只有小写英文字母</li>
</ul>
<p>外国友人仿照中国字谜设计了一个英文版猜字谜小游戏,请你来猜猜看吧。</p>
<p>字谜的迷面 <code>puzzle</code> 按字符串形式给出,如果一个单词 <code>word</code> 符合下面两个条件,那么它就可以算作谜底:</p>
<ul>
<li>单词 <code>word</code> 中包含谜面 <code>puzzle</code> 的第一个字母。</li>
<li>单词 <code>word</code> 中的每一个字母都可以在谜面 <code>puzzle</code> 中找到。<br />
例如,如果字谜的谜面是 "abcdefg",那么可以作为谜底的单词有 "faced", "cabbage", 和 "baggage";而 "beefed"(不含字母 "a")以及 "based"(其中的 "s" 没有出现在谜面中)都不能作为谜底。</li>
</ul>
<p>返回一个答案数组 <code>answer</code>,数组中的每个元素 <code>answer[i]</code> 是在给出的单词列表 <code>words</code> 中可以作为字谜迷面 <code>puzzles[i]</code> 所对应的谜底的单词数目。</p>
<p> </p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入:</strong>
words = ["aaaa","asas","able","ability","actt","actor","access"],
puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
<strong>输出:</strong>[1,1,3,2,4,0]
<strong>解释:</strong>
1 个单词可以作为 "aboveyz" 的谜底 : "aaaa"
1 个单词可以作为 "abrodyz" 的谜底 : "aaaa"
3 个单词可以作为 "abslute" 的谜底 : "aaaa", "asas", "able"
2 个单词可以作为 "absoryz" 的谜底 : "aaaa", "asas"
4 个单词可以作为 "actresz" 的谜底 : "aaaa", "asas", "actt", "access"
没有单词可以作为 "gaswxyz" 的谜底,因为列表中的单词都不含字母 'g'。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= words.length <= 10^5</code></li>
<li><code>4 <= words[i].length <= 50</code></li>
<li><code>1 <= puzzles.length <= 10^4</code></li>
<li><code>puzzles[i].length == 7</code></li>
<li><code>words[i][j]</code>, <code>puzzles[i][j]</code> 都是小写英文字母。</li>
<li>每个 <code>puzzles[i]</code> 所包含的字符都不重复。</li>
</ul>
<p>部门表&nbsp;<code>Department</code></p>
<pre>
+---------------+---------+
| Column Name | Type |
+---------------+---------+
| id | int |
| revenue | int |
| month | varchar |
+---------------+---------+
(id, month) 是表的联合主键。
这个表格有关于每个部门每月收入的信息。
月份(month)可以取下列值 [&quot;Jan&quot;,&quot;Feb&quot;,&quot;Mar&quot;,&quot;Apr&quot;,&quot;May&quot;,&quot;Jun&quot;,&quot;Jul&quot;,&quot;Aug&quot;,&quot;Sep&quot;,&quot;Oct&quot;,&quot;Nov&quot;,&quot;Dec&quot;]。
</pre>
<p>&nbsp;</p>
<p>编写一个 SQL 查询来重新格式化表,使得新的表中有一个部门 id 列和一些对应&nbsp;<strong>每个月 </strong>的收入(revenue)列。</p>
<p>查询结果格式如下面的示例所示:</p>
<pre>
Department 表:
+------+---------+-------+
| id | revenue | month |
+------+---------+-------+
| 1 | 8000 | Jan |
| 2 | 9000 | Jan |
| 3 | 10000 | Feb |
| 1 | 7000 | Feb |
| 1 | 6000 | Mar |
+------+---------+-------+
查询得到的结果表:
+------+-------------+-------------+-------------+-----+-------------+
| id | Jan_Revenue | Feb_Revenue | Mar_Revenue | ... | Dec_Revenue |
+------+-------------+-------------+-------------+-----+-------------+
| 1 | 8000 | 7000 | 6000 | ... | null |
| 2 | 9000 | null | null | ... | null |
| 3 | null | 10000 | null | ... | null |
+------+-------------+-------------+-------------+-----+-------------+
注意,结果表有 13 列 (1个部门 id 列 + 12个月份的收入列)。
</pre>
<p>给你一个整数数组,返回它的某个&nbsp;<strong>非空</strong> 子数组(连续元素)在执行一次可选的删除操作后,所能得到的最大元素总和。</p>
<p>换句话说,你可以从原数组中选出一个子数组,并可以决定要不要从中删除一个元素(只能删一次哦),(删除后)子数组中至少应当有一个元素,然后该子数组(剩下)的元素总和是所有子数组之中最大的。</p>
<p>注意,删除一个元素后,子数组 <strong>不能为空</strong></p>
<p>请看示例:</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [1,-2,0,3]
<strong>输出:</strong>4
<strong>解释:</strong>我们可以选出 [1, -2, 0, 3],然后删掉 -2,这样得到 [1, 0, 3],和最大。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,-2,-2,3]
<strong>输出:</strong>3
<strong>解释:</strong>我们直接选出 [3],这就是最大和。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [-1,-1,-1,-1]
<strong>输出:</strong>-1
<strong>解释:</strong>最后得到的子数组不能为空,所以我们不能选择 [-1] 并从中删去 -1 来得到 0。
我们应该直接选择 [-1],或者选择 [-1, -1] 再从中删去一个 -1。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>-10^4 &lt;= arr[i] &lt;= 10^4</code></li>
</ul>
<p>给你两个整数数组&nbsp;<code>arr1</code><code>arr2</code>,返回使&nbsp;<code>arr1</code>&nbsp;严格递增所需要的最小「操作」数(可能为 0)。</p>
<p>每一步「操作」中,你可以分别从 <code>arr1</code><code>arr2</code> 中各选出一个索引,分别为&nbsp;<code>i</code>&nbsp;<code>j</code><code>0 &lt;=&nbsp;i &lt; arr1.length</code>&nbsp;&nbsp;<code>0 &lt;= j &lt; arr2.length</code>,然后进行赋值运算&nbsp;<code>arr1[i] = arr2[j]</code></p>
<p>如果无法让&nbsp;<code>arr1</code>&nbsp;严格递增,请返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]
<strong>输出:</strong>1
<strong>解释:</strong>用 2 来替换 <code>5,之后</code> <code>arr1 = [1, 2, 3, 6, 7]</code>
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,5,3,6,7], arr2 = [4,3,1]
<strong>输出:</strong>2
<strong>解释:</strong>用 3 来替换 <code>5,然后</code>用 4 来替换 3<code>,得到</code> <code>arr1 = [1, 3, 4, 6, 7]</code>
</pre>
<p><strong>示例&nbsp;3:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]
<strong>输出:</strong>-1
<strong>解释:</strong>无法使 <code>arr1 严格递增</code></pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr1.length, arr2.length &lt;= 2000</code></li>
<li><code>0 &lt;= arr1[i], arr2[i] &lt;= 10^9</code></li>
</ul>
<p>&nbsp;</p>
<p>给你一个整数数组&nbsp;<code>arr</code>&nbsp;和一个整数&nbsp;<code>k</code></p>
<p>首先,我们要对该数组进行修改,即把原数组 <code>arr</code> 重复&nbsp;<code>k</code>&nbsp;次。</p>
<blockquote>
<p>举个例子,如果&nbsp;<code>arr&nbsp;= [1, 2]</code><code>k = 3</code>,那么修改后的数组就是&nbsp;<code>[1, 2, 1, 2, 1, 2]</code></p>
</blockquote>
<p>然后,请你返回修改后的数组中的最大的子数组之和。</p>
<p>注意,子数组长度可以是 <code>0</code>,在这种情况下它的总和也是 <code>0</code></p>
<p>由于&nbsp;<strong>结果可能会很大</strong>,所以需要 <strong>模(mod)</strong>&nbsp;<code>10^9 + 7</code>&nbsp;后再返回。&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [1,2], k = 3
<strong>输出:</strong>9
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,-2,1], k = 5
<strong>输出:</strong>2
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [-1,-2], k = 7
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>1 &lt;= k &lt;= 10^5</code></li>
<li><code>-10^4 &lt;= arr[i] &lt;= 10^4</code></li>
</ul>
<p>编写一个可以从 1 到 n 输出代表这个数字的字符串的程序,但是:</p>
<ul>
<li>如果这个数字可以被 3 整除,输出 "fizz"。</li>
<li>如果这个数字可以被 5 整除,输出 "buzz"。</li>
<li>如果这个数字可以同时被 3 和 5 整除,输出 "fizzbuzz"。</li>
</ul>
<p>例如,当 <code>n = 15</code>,输出: <code>1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz</code></p>
<p>假设有这么一个类:</p>
<pre>
class FizzBuzz {
  public FizzBuzz(int n) { ... }  // constructor
public void fizz(printFizz) { ... } // only output "fizz"
public void buzz(printBuzz) { ... } // only output "buzz"
public void fizzbuzz(printFizzBuzz) { ... } // only output "fizzbuzz"
public void number(printNumber) { ... } // only output the numbers
}</pre>
<p>请你实现一个有四个线程的多线程版  <code>FizzBuzz</code>, 同一个 <code>FizzBuzz</code> 实例会被如下四个线程使用:</p>
<ol>
<li>线程A将调用 <code>fizz()</code> 来判断是否能被 3 整除,如果可以,则输出 <code>fizz</code></li>
<li>线程B将调用 <code>buzz()</code> 来判断是否能被 5 整除,如果可以,则输出 <code>buzz</code></li>
<li>线程C将调用 <code>fizzbuzz()</code> 来判断是否同时能被 3 和 5 整除,如果可以,则输出 <code>fizzbuzz</code></li>
<li>线程D将调用 <code>number()</code> 来实现输出既不能被 3 整除也不能被 5 整除的数字。</li>
</ol>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>本题已经提供了打印字符串的相关方法,如 <code>printFizz()</code> 等,具体方法名请参考答题模板中的注释部分。</li>
</ul>
<p> </p>
<p>给你个整数数组&nbsp;<code>arr</code>,其中每个元素都 <strong>不相同</strong></p>
<p>请你找到所有具有最小绝对差的元素对,并且按升序的顺序返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [4,2,1,3]
<strong>输出:</strong>[[1,2],[2,3],[3,4]]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,3,6,10,15]
<strong>输出:</strong>[[1,3]]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [3,8,-10,23,19,-4,-14,27]
<strong>输出:</strong>[[-14,-10],[19,23],[23,27]]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>-10^6 &lt;= arr[i] &lt;= 10^6</code></li>
</ul>
<p>给你四个整数:<code>n</code><code>a</code><code>b</code><code>c</code> ,请你设计一个算法来找出第 <code>n</code> 个丑数。</p>
<p>丑数是可以被 <code>a</code> <strong></strong> <code>b</code> <strong></strong> <code>c</code> 整除的 <strong>正整数</strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>n = 3, a = 2, b = 3, c = 5
<strong>输出:</strong>4
<strong>解释:</strong>丑数序列为 2, 3, 4, 5, 6, 8, 9, 10... 其中第 3 个是 4。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>n = 4, a = 2, b = 3, c = 4
<strong>输出:</strong>6
<strong>解释:</strong>丑数序列为 2, 3, 4, 6, 8, 9, 10, 12... 其中第 4 个是 6。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>n = 5, a = 2, b = 11, c = 13
<strong>输出:</strong>10
<strong>解释:</strong>丑数序列为 2, 4, 6, 8, 10, 11, 12, 13... 其中第 5 个是 10。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>n = 1000000000, a = 2, b = 217983653, c = 336916467
<strong>输出:</strong>1999999984
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= n, a, b, c <= 10^9</code></li>
<li><code>1 <= a * b * c <= 10^18</code></li>
<li>本题结果在 <code>[1, 2 * 10^9]</code> 的范围内</li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>,以及该字符串中的一些「索引对」数组&nbsp;<code>pairs</code>,其中&nbsp;<code>pairs[i] =&nbsp;[a, b]</code>&nbsp;表示字符串中的两个索引(编号从 0 开始)。</p>
<p>你可以 <strong>任意多次交换</strong>&nbsp;<code>pairs</code>&nbsp;中任意一对索引处的字符。</p>
<p>返回在经过若干次交换后,<code>s</code>&nbsp;可以变成的按字典序最小的字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;dcab&quot;, pairs = [[0,3],[1,2]]
<strong>输出:</strong>&quot;bacd&quot;
<strong>解释:</strong>
交换 s[0] 和 s[3], s = &quot;bcad&quot;
交换 s[1] 和 s[2], s = &quot;bacd&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;dcab&quot;, pairs = [[0,3],[1,2],[0,2]]
<strong>输出:</strong>&quot;abcd&quot;
<strong>解释:</strong>
交换 s[0] 和 s[3], s = &quot;bcad&quot;
交换 s[0] 和 s[2], s = &quot;acbd&quot;
交换 s[1] 和 s[2], s = &quot;abcd&quot;</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;cba&quot;, pairs = [[0,1],[1,2]]
<strong>输出:</strong>&quot;abc&quot;
<strong>解释:</strong>
交换 s[0] 和 s[1], s = &quot;bca&quot;
交换 s[1] 和 s[2], s = &quot;bac&quot;
交换 s[0] 和 s[1], s = &quot;abc&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>0 &lt;= pairs.length &lt;= 10^5</code></li>
<li><code>0 &lt;= pairs[i][0], pairs[i][1] &lt;&nbsp;s.length</code></li>
<li><code>s</code>&nbsp;中只含有小写英文字母</li>
</ul>
<p><code>n</code> 个项目,每个项目或者不属于任何小组,或者属于 <code>m</code> 个小组之一。<code>group[i]</code> 表示第 <code>i</code> 个项目所属的小组,如果第 <code>i</code> 个项目不属于任何小组,则 <code>group[i]</code> 等于 <code>-1</code>。项目和小组都是从零开始编号的。可能存在小组不负责任何项目,即没有任何项目属于这个小组。</p>
<p>请你帮忙按要求安排这些项目的进度,并返回排序后的项目列表:</p>
<ul>
<li>同一小组的项目,排序后在列表中彼此相邻。</li>
<li>项目之间存在一定的依赖关系,我们用一个列表 <code>beforeItems</code> 来表示,其中 <code>beforeItems[i]</code> 表示在进行第 <code>i</code> 个项目前(位于第 <code>i</code> 个项目左侧)应该完成的所有项目。</li>
</ul>
<p>如果存在多个解决方案,只需要返回其中任意一个即可。如果没有合适的解决方案,就请返回一个 <strong>空列表 </strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/22/1359_ex1.png" style="height: 181px; width: 191px;" /></strong></p>
<pre>
<strong>输入:</strong>n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3,6],[],[],[]]
<strong>输出:</strong>[6,3,4,1,5,2,0,7]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3],[],[4],[]]
<strong>输出:</strong>[]
<strong>解释:</strong>与示例 1 大致相同,但是在排序后的列表中,4 必须放在 6 的前面。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= m <= n <= 3 * 10<sup>4</sup></code></li>
<li><code>group.length == beforeItems.length == n</code></li>
<li><code>-1 <= group[i] <= m - 1</code></li>
<li><code>0 <= beforeItems[i].length <= n - 1</code></li>
<li><code>0 <= beforeItems[i][j] <= n - 1</code></li>
<li><code>i != beforeItems[i][j]</code></li>
<li><code>beforeItems[i]</code> 不含重复元素</li>
</ul>
<p>不使用任何库函数,设计一个跳表。</p>
<p>跳表是在 O(log(n)) 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树,其功能与性能相当,并且跳表的代码长度相较下更短,其设计思想与链表相似。</p>
<p>例如,一个跳表包含 [30, 40, 50, 60, 70, 90],然后增加 80、45 到跳表中,以下图的方式操作:</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/09/27/1506_skiplist.gif" style="width: 500px;"><br>
<small>Artyom Kalinin [CC BY-SA 3.0], via <a href="https://commons.wikimedia.org/wiki/File:Skip_list_add_element-en.gif" target="_blank" title="Artyom Kalinin [CC BY-SA 3.0 (https://creativecommons.org/licenses/by-sa/3.0)], via Wikimedia Commons">Wikimedia Commons</a></small></p>
<p>跳表中有很多层,每一层是一个短的链表。在第一层的作用下,增加、删除和搜索操作的时间复杂度不超过 O(n)。跳表的每一个操作的平均时间复杂度是 O(log(n)),空间复杂度是 O(n)。</p>
<p>在本题中,你的设计应该要包含这些函数:</p>
<ul>
<li><code>bool search(int target)</code> : 返回target是否存在于跳表中。</li>
<li><code>void add(int num)</code>:&nbsp;插入一个元素到跳表。</li>
<li><code>bool erase(int num)</code>: 在跳表中删除一个值,如果&nbsp;<code>num</code>&nbsp;不存在,直接返回false. 如果存在多个&nbsp;<code>num</code>&nbsp;,删除其中任意一个即可。</li>
</ul>
<p>了解更多 :&nbsp;<a href="https://en.wikipedia.org/wiki/Skip_list" target="_blank">https://en.wikipedia.org/wiki/Skip_list</a></p>
<p>注意,跳表中可能存在多个相同的值,你的代码需要处理这种情况。</p>
<p><strong>样例:</strong></p>
<pre>Skiplist skiplist = new Skiplist();
skiplist.add(1);
skiplist.add(2);
skiplist.add(3);
skiplist.search(0); // 返回 false
skiplist.add(4);
skiplist.search(1); // 返回 true
skiplist.erase(0); // 返回 false,0 不在跳表中
skiplist.erase(1); // 返回 true
skiplist.search(1); // 返回 false,1 已被擦除
</pre>
<p><strong>约束条件:</strong></p>
<ul>
<li><code>0 &lt;= num, target&nbsp;&lt;= 20000</code></li>
<li>最多调用&nbsp;<code>50000</code>&nbsp;&nbsp;<code>search</code>, <code>add</code>, 以及&nbsp;<code>erase</code>操作。</li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>,请你帮忙统计数组中每个数的出现次数。</p>
<p>如果每个数的出现次数都是独一无二的,就返回&nbsp;<code>true</code>;否则返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,2,1,1,3]
<strong>输出:</strong>true
<strong>解释:</strong>在该数组中,1 出现了 3 次,2 出现了 2 次,3 只出现了 1 次。没有两个数的出现次数相同。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,2]
<strong>输出:</strong>false
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [-3,0,1,-3,1,1,1,-3,10,0]
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length&nbsp;&lt;= 1000</code></li>
<li><code>-1000 &lt;= arr[i] &lt;= 1000</code></li>
</ul>
<p>给你两个长度相同的字符串,<code>s</code><code>t</code></p>
<p><code>s</code> 中的第 <code>i</code> 个字符变到 <code>t</code> 中的第 <code>i</code> 个字符需要 <code>|s[i] - t[i]|</code> 的开销(开销可能为 0),也就是两个字符的 ASCII 码值的差的绝对值。</p>
<p>用于变更字符串的最大预算是 <code>maxCost</code>。在转化字符串时,总开销应当小于等于该预算,这也意味着字符串的转化可能是不完全的。</p>
<p>如果你可以将 <code>s</code> 的子字符串转化为它在 <code>t</code> 中对应的子字符串,则返回可以转化的最大长度。</p>
<p>如果 <code>s</code> 中没有子字符串可以转化成 <code>t</code> 中对应的子字符串,则返回 <code>0</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "abcd", t = "bcdf", maxCost = 3
<strong>输出:</strong>3
<strong>解释:</strong>s<strong> </strong>中的<strong> </strong>"abc" 可以变为 "bcd"。开销为 3,所以最大长度为 3。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "abcd", t = "cdef", maxCost = 3
<strong>输出:</strong>1
<strong>解释:</strong>s 中的任一字符要想变成 t 中对应的字符,其开销都是 2。因此,最大长度为<code> 1。</code>
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "abcd", t = "acde", maxCost = 0
<strong>输出:</strong>1
<strong>解释:</strong>a -> a, cost = 0,字符串未发生变化,所以最大长度为 1。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length, t.length <= 10^5</code></li>
<li><code>0 <= maxCost <= 10^6</code></li>
<li><code>s</code> 和 <code>t</code> 都只含小写英文字母。</li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>,「<code>k</code> 倍重复项删除操作」将会从 <code>s</code>&nbsp;中选择&nbsp;<code>k</code>&nbsp;个相邻且相等的字母,并删除它们,使被删去的字符串的左侧和右侧连在一起。</p>
<p>你需要对&nbsp;<code>s</code>&nbsp;重复进行无限次这样的删除操作,直到无法继续为止。</p>
<p>在执行完所有删除操作后,返回最终得到的字符串。</p>
<p>本题答案保证唯一。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;abcd&quot;, k = 2
<strong>输出:</strong>&quot;abcd&quot;
<strong>解释:</strong>没有要删除的内容。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;deeedbbcccbdaa&quot;, k = 3
<strong>输出:</strong>&quot;aa&quot;
<strong>解释:
</strong>先删除 &quot;eee&quot;&quot;ccc&quot;,得到 &quot;ddbbbdaa&quot;
再删除 &quot;bbb&quot;,得到 &quot;dddaa&quot;
最后删除 &quot;ddd&quot;,得到 &quot;aa&quot;</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;pbbcggttciiippooaais&quot;, k = 2
<strong>输出:</strong>&quot;ps&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>2 &lt;= k &lt;= 10^4</code></li>
<li><code>s</code>&nbsp;中只含有小写英文字母。</li>
</ul>
<p>你还记得那条风靡全球的贪吃蛇吗?</p>
<p>我们在一个&nbsp;<code>n*n</code>&nbsp;的网格上构建了新的迷宫地图,蛇的长度为 2,也就是说它会占去两个单元格。蛇会从左上角(<code>(0, 0)</code>&nbsp;&nbsp;<code>(0, 1)</code>)开始移动。我们用 <code>0</code> 表示空单元格,用 1 表示障碍物。蛇需要移动到迷宫的右下角(<code>(n-1, n-2)</code>&nbsp;&nbsp;<code>(n-1, n-1)</code>)。</p>
<p>每次移动,蛇可以这样走:</p>
<ul>
<li>如果没有障碍,则向右移动一个单元格。并仍然保持身体的水平/竖直状态。</li>
<li>如果没有障碍,则向下移动一个单元格。并仍然保持身体的水平/竖直状态。</li>
<li>如果它处于水平状态并且其下面的两个单元都是空的,就顺时针旋转 90 度。蛇从(<code>(r, c)</code><code>(r, c+1)</code>)移动到 (<code>(r, c)</code><code>(r+1, c)</code>)。<br>
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/28/image-2.png" style="height: 134px; width: 300px;"></li>
<li>如果它处于竖直状态并且其右面的两个单元都是空的,就逆时针旋转 90 度。蛇从(<code>(r, c)</code><code>(r+1, c)</code>)移动到(<code>(r, c)</code><code>(r, c+1)</code>)。<br>
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/28/image-1.png" style="height: 121px; width: 300px;"></li>
</ul>
<p>返回蛇抵达目的地所需的最少移动次数。</p>
<p>如果无法到达目的地,请返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/28/image.png" style="height: 439px; width: 400px;"></strong></p>
<pre><strong>输入:</strong>grid = [[0,0,0,0,0,1],
[1,1,0,0,1,0],
&nbsp; [0,0,0,0,1,1],
&nbsp; [0,0,1,0,1,0],
&nbsp; [0,1,1,0,0,0],
&nbsp; [0,1,1,0,0,0]]
<strong>输出:</strong>11
<strong>解释:
</strong>一种可能的解决方案是 [右, 右, 顺时针旋转, 右, 下, 下, 下, 下, 逆时针旋转, 右, 下]。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>grid = [[0,0,1,1,1,1],
&nbsp; [0,0,0,0,1,1],
&nbsp; [1,1,0,0,0,1],
&nbsp; [1,1,1,0,0,1],
&nbsp; [1,1,1,0,0,1],
&nbsp; [1,1,1,0,0,0]]
<strong>输出:</strong>9
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 100</code></li>
<li><code>0 &lt;= grid[i][j] &lt;= 1</code></li>
<li>蛇保证从空单元格开始出发。</li>
</ul>
<p>给定一个数组 <code>prices</code> ,它的第 <code>i</code> 个元素 <code>prices[i]</code> 表示一支给定股票第 <code>i</code> 天的价格。</p>
<p>你只能选择 <strong>某一天</strong> 买入这只股票,并选择在 <strong>未来的某一个不同的日子</strong> 卖出该股票。设计一个算法来计算你所能获取的最大利润。</p>
<p>返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 <code>0</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>[7,1,5,3,6,4]
<strong>输出:</strong>5
<strong>解释:</strong>在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格;同时,你不能在买入前卖出股票。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>prices = [7,6,4,3,1]
<strong>输出:</strong>0
<strong>解释:</strong>在这种情况下, 没有交易完成, 所以最大利润为 0。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= prices.length <= 10<sup>5</sup></code></li>
<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
</ul>
<p>数轴上放置了一些筹码,每个筹码的位置存在数组&nbsp;<code>chips</code>&nbsp;当中。</p>
<p>你可以对 <strong>任何筹码</strong> 执行下面两种操作之一(<strong>不限操作次数</strong>,0 次也可以):</p>
<ul>
<li>将第 <code>i</code> 个筹码向左或者右移动 2 个单位,代价为 <strong>0</strong></li>
<li>将第 <code>i</code> 个筹码向左或者右移动 1 个单位,代价为 <strong>1</strong></li>
</ul>
<p>最开始的时候,同一位置上也可能放着两个或者更多的筹码。</p>
<p>返回将所有筹码移动到同一位置(任意位置)上所需要的最小代价。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>chips = [1,2,3]
<strong>输出:</strong>1
<strong>解释:</strong>第二个筹码移动到位置三的代价是 1,第一个筹码移动到位置三的代价是 0,总代价为 1。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>chips = [2,2,2,3,3]
<strong>输出:</strong>2
<strong>解释:</strong>第四和第五个筹码移动到位置二的代价都是 1,所以最小总代价为 2。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= chips.length &lt;= 100</code></li>
<li><code>1 &lt;= chips[i] &lt;= 10^9</code></li>
</ul>
<p>给你一个整数数组 <code>arr</code> 和一个整数 <code>difference</code>,请你找出并返回 <code>arr</code> 中最长等差子序列的长度,该子序列中相邻元素之间的差等于 <code>difference</code></p>
<p><strong>子序列</strong> 是指在不改变其余元素顺序的情况下,通过删除一些元素或不删除任何元素而从 <code>arr</code> 派生出来的序列。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,2,3,4], difference = 1
<strong>输出:</strong>4
<strong>解释:</strong>最长的等差子序列是 [1,2,3,4]。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,3,5,7], difference = 1
<strong>输出:</strong>1
<strong>解释:</strong>最长的等差子序列是任意单个元素。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,5,7,8,5,3,4,2,1], difference = -2
<strong>输出:</strong>4
<strong>解释:</strong>最长的等差子序列是 [7,5,3,1]。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= arr.length <= 10<sup>5</sup></code></li>
<li><code>-10<sup>4</sup> <= arr[i], difference <= 10<sup>4</sup></code></li>
</ul>
<p>你要开发一座金矿,地质勘测学家已经探明了这座金矿中的资源分布,并用大小为&nbsp;<code>m * n</code> 的网格 <code>grid</code> 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量;如果该单元格是空的,那么就是 <code>0</code></p>
<p>为了使收益最大化,矿工需要按以下规则来开采黄金:</p>
<ul>
<li>每当矿工进入一个单元,就会收集该单元格中的所有黄金。</li>
<li>矿工每次可以从当前位置向上下左右四个方向走。</li>
<li>每个单元格只能被开采(进入)一次。</li>
<li><strong>不得开采</strong>(进入)黄金数目为 <code>0</code> 的单元格。</li>
<li>矿工可以从网格中 <strong>任意一个</strong> 有黄金的单元格出发或者是停止。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>grid = [[0,6,0],[5,8,7],[0,9,0]]
<strong>输出:</strong>24
<strong>解释:</strong>
[[0,6,0],
[5,8,7],
[0,9,0]]
一种收集最多黄金的路线是:9 -&gt; 8 -&gt; 7。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]
<strong>输出:</strong>28
<strong>解释:</strong>
[[1,0,7],
[2,0,6],
[3,4,5],
[0,3,0],
[9,0,20]]
一种收集最多黄金的路线是:1 -&gt; 2 -&gt; 3 -&gt; 4 -&gt; 5 -&gt; 6 -&gt; 7。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= grid.length,&nbsp;grid[i].length &lt;= 15</code></li>
<li><code>0 &lt;= grid[i][j] &lt;= 100</code></li>
<li>最多 <strong>25 </strong>个单元格中有黄金。</li>
</ul>
<p>给你一个整数&nbsp;<code>n</code>,请你帮忙统计一下我们可以按下述规则形成多少个长度为&nbsp;<code>n</code>&nbsp;的字符串:</p>
<ul>
<li>字符串中的每个字符都应当是小写元音字母(<code>&#39;a&#39;</code>, <code>&#39;e&#39;</code>, <code>&#39;i&#39;</code>, <code>&#39;o&#39;</code>, <code>&#39;u&#39;</code></li>
<li>每个元音&nbsp;<code>&#39;a&#39;</code>&nbsp;后面都只能跟着&nbsp;<code>&#39;e&#39;</code></li>
<li>每个元音&nbsp;<code>&#39;e&#39;</code>&nbsp;后面只能跟着&nbsp;<code>&#39;a&#39;</code>&nbsp;或者是&nbsp;<code>&#39;i&#39;</code></li>
<li>每个元音&nbsp;<code>&#39;i&#39;</code>&nbsp;后面&nbsp;<strong>不能</strong> 再跟着另一个&nbsp;<code>&#39;i&#39;</code></li>
<li>每个元音&nbsp;<code>&#39;o&#39;</code>&nbsp;后面只能跟着&nbsp;<code>&#39;i&#39;</code>&nbsp;或者是&nbsp;<code>&#39;u&#39;</code></li>
<li>每个元音&nbsp;<code>&#39;u&#39;</code>&nbsp;后面只能跟着&nbsp;<code>&#39;a&#39;</code></li>
</ul>
<p>由于答案可能会很大,所以请你返回 模&nbsp;<code>10^9 + 7</code>&nbsp;之后的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 1
<strong>输出:</strong>5
<strong>解释:</strong>所有可能的字符串分别是:&quot;a&quot;, &quot;e&quot;, &quot;i&quot; , &quot;o&quot;&quot;u&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>10
<strong>解释:</strong>所有可能的字符串分别是:&quot;ae&quot;, &quot;ea&quot;, &quot;ei&quot;, &quot;ia&quot;, &quot;ie&quot;, &quot;io&quot;, &quot;iu&quot;, &quot;oi&quot;, &quot;ou&quot;&quot;ua&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 5
<strong>输出:</strong>68</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 2 * 10^4</code></li>
</ul>
<p>给定一个数组 <code>prices</code> ,其中 <code>prices[i]</code> 是一支给定股票第 <code>i</code> 天的价格。</p>
<p>设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。</p>
<p><strong>注意:</strong>你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong> prices = [7,1,5,3,6,4]
<strong>输出:</strong> 7
<strong>解释:</strong> 在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
  随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong> prices = [1,2,3,4,5]
<strong>输出:</strong> 4
<strong>解释:</strong> 在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
  注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong> prices = [7,6,4,3,1]
<strong>输出:</strong> 0
<strong>解释:</strong> 在这种情况下, 没有交易完成, 所以最大利润为 0。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= prices.length <= 3 * 10<sup>4</sup></code></li>
<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
</ul>
<p>在一个 <strong>平衡字符串</strong> 中,<code>'L'</code><code>'R'</code> 字符的数量是相同的。</p>
<p>给你一个平衡字符串&nbsp;<code>s</code>,请你将它分割成尽可能多的平衡字符串。</p>
<p><strong>注意:</strong>分割得到的每个字符串都必须是平衡字符串,且分割得到的平衡字符串是原平衡字符串的连续子串。</p>
<p>返回可以通过分割得到的平衡字符串的 <strong>最大数量</strong> <strong></strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "RLRRLLRLRL"
<strong>输出:</strong>4
<strong>解释:</strong>s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "RLLLLRRRLR"
<strong>输出:</strong>3
<strong>解释:</strong>s 可以分割为 "RL"、"LLLRRR"、"LR" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "LLLLRRRR"
<strong>输出:</strong>1
<strong>解释:</strong>s 只能保持原样 "LLLLRRRR".
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>s = "RLRRRLLRLL"
<strong>输出:</strong>2
<strong>解释:</strong>s 可以分割为 "RL"、"RRRLLRLL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 1000</code></li>
<li><code>s[i] = 'L' 或 'R'</code></li>
<li><code>s</code> 是一个 <strong>平衡</strong> 字符串</li>
</ul>
<p>在一个 <strong>8x8</strong> 的棋盘上,放置着若干「黑皇后」和一个「白国王」。</p>
<p>「黑皇后」在棋盘上的位置分布用整数坐标数组 <code>queens</code> 表示,「白国王」的坐标用数组 <code>king</code> 表示。</p>
<p>「黑皇后」的行棋规定是:横、直、斜都可以走,步数不受限制,但是,不能越子行棋。</p>
<p>请你返回可以直接攻击到「白国王」的所有「黑皇后」的坐标(任意顺序)。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/13/untitled-diagram.jpg" style="width: 250px;" /></p>
<pre>
<strong>输入:</strong>queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
<strong>输出:</strong>[[0,1],[1,0],[3,3]]
<strong>解释:</strong>
[0,1] 的皇后可以攻击到国王,因为他们在同一行上。
[1,0] 的皇后可以攻击到国王,因为他们在同一列上。
[3,3] 的皇后可以攻击到国王,因为他们在同一条对角线上。
[0,4] 的皇后无法攻击到国王,因为她被位于 [0,1] 的皇后挡住了。
[4,0] 的皇后无法攻击到国王,因为她被位于 [1,0] 的皇后挡住了。
[2,4] 的皇后无法攻击到国王,因为她和国王不在同一行/列/对角线上。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/13/untitled-diagram-1.jpg" style="height: 321px; width: 321px;" /></strong></p>
<pre>
<strong>输入:</strong>queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]
<strong>输出:</strong>[[2,2],[3,4],[4,4]]
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/13/untitled-diagram-2.jpg" style="height: 321px; width: 321px;" /></strong></p>
<pre>
<strong>输入:</strong>queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[3,7],[0,3],[4,0],[1,2],[6,3],[5,0],[0,4],[2,2],[1,1],[6,4],[5,4],[0,0],[2,6],[4,5],[5,2],[1,4],[7,5],[2,3],[0,5],[4,2],[1,0],[2,7],[0,1],[4,6],[6,1],[0,6],[4,3],[1,7]], king = [3,4]
<strong>输出:</strong>[[2,3],[1,4],[1,6],[3,7],[4,3],[5,4],[4,5]]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= queens.length <= 63</code></li>
<li><code>queens[i].length == 2</code></li>
<li><code>0 <= queens[i][j] < 8</code></li>
<li><code>king.length == 2</code></li>
<li><code>0 <= king[0], king[1] < 8</code></li>
<li>一个棋盘格上最多只能放置一枚棋子。</li>
</ul>
<p>有一个骰子模拟器会每次投掷的时候生成一个 1 到 6 的随机数。</p>
<p>不过我们在使用它时有个约束,就是使得投掷骰子时,<strong>连续</strong> 掷出数字&nbsp;<code>i</code>&nbsp;的次数不能超过&nbsp;<code>rollMax[i]</code><code>i</code>&nbsp;从 1 开始编号)。</p>
<p>现在,给你一个整数数组&nbsp;<code>rollMax</code>&nbsp;和一个整数&nbsp;<code>n</code>,请你来计算掷&nbsp;<code>n</code>&nbsp;次骰子可得到的不同点数序列的数量。</p>
<p>假如两个序列中至少存在一个元素不同,就认为这两个序列是不同的。由于答案可能很大,所以请返回 <strong>&nbsp;<code>10^9 + 7</code></strong>&nbsp;之后的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 2, rollMax = [1,1,2,2,2,3]
<strong>输出:</strong>34
<strong>解释:</strong>我们掷 2 次骰子,如果没有约束的话,共有 6 * 6 = 36 种可能的组合。但是根据 rollMax 数组,数字 1 和 2 最多连续出现一次,所以不会出现序列 (1,1) 和 (2,2)。因此,最终答案是 36-2 = 34。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2, rollMax = [1,1,1,1,1,1]
<strong>输出:</strong>30
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 3, rollMax = [1,1,1,2,2,3]
<strong>输出:</strong>181
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 5000</code></li>
<li><code>rollMax.length == 6</code></li>
<li><code>1 &lt;= rollMax[i] &lt;= 15</code></li>
</ul>
<p>给出一个正整数数组&nbsp;<code>nums</code>,请你帮忙从该数组中找出能满足下面要求的 <strong>最长</strong> 前缀,并返回其长度:</p>
<ul>
<li>从前缀中 <strong>删除一个</strong> 元素后,使得所剩下的每个数字的出现次数相同。</li>
</ul>
<p>如果删除这个元素后没有剩余元素存在,仍可认为每个数字都具有相同的出现次数(也就是 0 次)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [2,2,1,1,5,3,3,5]
<strong>输出:</strong>7
<strong>解释:</strong>对于长度为 7 的子数组 [2,2,1,1,5,3,3],如果我们从中删去 nums[4]=5,就可以得到 [2,2,1,1,3,3],里面每个数字都出现了两次。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,1,2,2,2,3,3,3,4,4,4,5]
<strong>输出:</strong>13
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,1,2,2,2]
<strong>输出:</strong>5
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums = [10,2,8,9,3,8,1,5,2,3,7,6]
<strong>输出:</strong>8
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^5</code></li>
</ul>
<p>5 个沉默寡言的哲学家围坐在圆桌前,每人面前一盘意面。叉子放在哲学家之间的桌面上。(5 个哲学家,5 根叉子)</p>
<p>所有的哲学家都只会在思考和进餐两种行为间交替。哲学家只有同时拿到左边和右边的叉子才能吃到面,而同一根叉子在同一时间只能被一个哲学家使用。每个哲学家吃完面后都需要把叉子放回桌面以供其他哲学家吃面。只要条件允许,哲学家可以拿起左边或者右边的叉子,但在没有同时拿到左右叉子时不能进食。</p>
<p>假设面的数量没有限制,哲学家也能随便吃,不需要考虑吃不吃得下。</p>
<p>设计一个进餐规则(并行算法)使得每个哲学家都不会挨饿;也就是说,在没有人知道别人什么时候想吃东西或思考的情况下,每个哲学家都可以在吃饭和思考之间一直交替下去。</p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/23/an_illustration_of_the_dining_philosophers_problem.png" style="height: 415px; width: 400px;"></p>
<p><em>问题描述和图片来自维基百科&nbsp;<a href="https://en.wikipedia.org/wiki/Dining_philosophers_problem" target="_blank">wikipedia.org</a></em></p>
<p>&nbsp;</p>
<p>哲学家从&nbsp;<strong>0</strong><strong>4</strong><strong>顺时针</strong> 编号。请实现函数&nbsp;<code>void wantsToEat(philosopher, pickLeftFork, pickRightFork, eat, putLeftFork, putRightFork)</code></p>
<ul>
<li><code>philosopher</code>&nbsp;哲学家的编号。</li>
<li><code>pickLeftFork</code>&nbsp;&nbsp;<code>pickRightFork</code>&nbsp;表示拿起左边或右边的叉子。</li>
<li><code>eat</code>&nbsp;表示吃面。</li>
<li><code>putLeftFork</code>&nbsp;&nbsp;<code>putRightFork</code>&nbsp;表示放下左边或右边的叉子。</li>
<li>由于哲学家不是在吃面就是在想着啥时候吃面,所以思考这个方法没有对应的回调。</li>
</ul>
<p>给你 5 个线程,每个都代表一个哲学家,请你使用类的同一个对象来模拟这个过程。在最后一次调用结束之前,可能会为同一个哲学家多次调用该函数。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>n = 1
<strong>输出:</strong>[[4,2,1],[4,1,1],[0,1,1],[2,2,1],[2,1,1],[2,0,3],[2,1,2],[2,2,2],[4,0,3],[4,1,2],[0,2,1],[4,2,2],[3,2,1],[3,1,1],[0,0,3],[0,1,2],[0,2,2],[1,2,1],[1,1,1],[3,0,3],[3,1,2],[3,2,2],[1,0,3],[1,1,2],[1,2,2]]
<strong>解释:</strong>
n 表示每个哲学家需要进餐的次数。
输出数组描述了叉子的控制和进餐的调用,它的格式如下:
output[i] = [a, b, c] (3个整数)
- a 哲学家编号。
- b 指定叉子:{1 : 左边, 2 : 右边}.
- c 指定行为:{1 : 拿起, 2 : 放下, 3 : 吃面}。
如 [4,2,1] 表示 4 号哲学家拿起了右边的叉子。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 60</code></li>
</ul>
<p><code>n</code> 位乘客即将登机,飞机正好有 <code>n</code> 个座位。第一位乘客的票丢了,他随便选了一个座位坐下。</p>
<p>剩下的乘客将会:</p>
<ul>
<li>
<p>如果他们自己的座位还空着,就坐到自己的座位上,</p>
</li>
<li>当他们自己的座位被占用时,随机选择其他座位</li>
</ul>
<p><code>n</code>&nbsp;位乘客坐在自己的座位上的概率是多少?</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>n = 1
<strong>输出:</strong>1.00000
<strong>解释:</strong>第一个人只会坐在自己的位置上。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong> n = 2
<strong>输出:</strong> 0.50000
<strong>解释:</strong>在第一个人选好座位坐下后,第二个人坐在自己的座位上的概率是 0.5。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
</ul>
<p>给定一个数组,它的第<em> </em><code>i</code> 个元素是一支给定的股票在第 <code>i</code><em> </em>天的价格。</p>
<p>设计一个算法来计算你所能获取的最大利润。你最多可以完成 <strong>两笔 </strong>交易。</p>
<p><strong>注意:</strong>你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>prices = [3,3,5,0,0,3,1,4]
<strong>输出:</strong>6
<strong>解释:</strong>在第 4 天(股票价格 = 0)的时候买入,在第 6 天(股票价格 = 3)的时候卖出,这笔交易所能获得利润 = 3-0 = 3 。
  随后,在第 7 天(股票价格 = 1)的时候买入,在第 8 天 (股票价格 = 4)的时候卖出,这笔交易所能获得利润 = 4-1 = 3 。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>prices = [1,2,3,4,5]
<strong>输出:</strong>4
<strong>解释:</strong>在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。  
  注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。  
  因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>prices = [7,6,4,3,1]
<strong>输出:</strong>0
<strong>解释:</strong>在这个情况下, 没有交易完成, 所以最大利润为 0。</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>prices = [1]
<strong>输出:</strong>0
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <prices.length <= 10<sup>5</sup></code></li>
<li><code>0 <prices[i] <= 10<sup>5</sup></code></li>
</ul>
<p>在一个&nbsp;XY 坐标系中有一些点,我们用数组&nbsp;<code>coordinates</code>&nbsp;来分别记录它们的坐标,其中&nbsp;<code>coordinates[i] = [x, y]</code>&nbsp;表示横坐标为 <code>x</code>、纵坐标为 <code>y</code>&nbsp;的点。</p>
<p>请你来判断,这些点是否在该坐标系中属于同一条直线上,是则返回 <code>true</code>,否则请返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/19/untitled-diagram-2.jpg" style="height: 336px; width: 336px;"></p>
<pre><strong>输入:</strong>coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/19/untitled-diagram-1.jpg" style="height: 336px; width: 348px;"></strong></p>
<pre><strong>输入:</strong>coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;=&nbsp;coordinates.length &lt;= 1000</code></li>
<li><code>coordinates[i].length == 2</code></li>
<li><code>-10^4 &lt;=&nbsp;coordinates[i][0],&nbsp;coordinates[i][1] &lt;= 10^4</code></li>
<li><code>coordinates</code>&nbsp;中不含重复的点</li>
</ul>
<p>你是一位系统管理员,手里有一份文件夹列表 <code>folder</code>,你的任务是要删除该列表中的所有 <strong>子文件夹</strong>,并以 <strong>任意顺序</strong> 返回剩下的文件夹。</p>
<p>我们这样定义「子文件夹」:</p>
<ul>
<li>如果文件夹&nbsp;<code>folder[i]</code>&nbsp;位于另一个文件夹&nbsp;<code>folder[j]</code>&nbsp;下,那么&nbsp;<code>folder[i]</code>&nbsp;就是&nbsp;<code>folder[j]</code>&nbsp;的子文件夹。</li>
</ul>
<p>文件夹的「路径」是由一个或多个按以下格式串联形成的字符串:</p>
<ul>
<li><code>/</code>&nbsp;后跟一个或者多个小写英文字母。</li>
</ul>
<p>例如,<code>/leetcode</code>&nbsp;&nbsp;<code>/leetcode/problems</code>&nbsp;都是有效的路径,而空字符串和&nbsp;<code>/</code>&nbsp;不是。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>folder = [&quot;/a&quot;,&quot;/a/b&quot;,&quot;/c/d&quot;,&quot;/c/d/e&quot;,&quot;/c/f&quot;]
<strong>输出:</strong>[&quot;/a&quot;,&quot;/c/d&quot;,&quot;/c/f&quot;]
<strong>解释:</strong>&quot;/a/b/&quot;&quot;/a&quot; 的子文件夹,而 &quot;/c/d/e&quot;&quot;/c/d&quot; 的子文件夹。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>folder = [&quot;/a&quot;,&quot;/a/b/c&quot;,&quot;/a/b/d&quot;]
<strong>输出:</strong>[&quot;/a&quot;]
<strong>解释:</strong>文件夹 &quot;/a/b/c&quot;&quot;/a/b/d/&quot; 都会被删除,因为它们都是 &quot;/a&quot; 的子文件夹。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>folder = [&quot;/a/b/c&quot;,&quot;/a/b/d&quot;,&quot;/a/b/ca&quot;]
<strong>输出:</strong>[&quot;/a/b/c&quot;,&quot;/a/b/ca&quot;,&quot;/a/b/d&quot;]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= folder.length&nbsp;&lt;= 4 * 10^4</code></li>
<li><code>2 &lt;= folder[i].length &lt;= 100</code></li>
<li><code>folder[i]</code>&nbsp;只包含小写字母和 <code>/</code></li>
<li><code>folder[i]</code>&nbsp;总是以字符 <code>/</code>&nbsp;起始</li>
<li>每个文件夹名都是唯一的</li>
</ul>
<p>有一个只含有&nbsp;<code>&#39;Q&#39;, &#39;W&#39;, &#39;E&#39;,&nbsp;&#39;R&#39;</code>&nbsp;四种字符,且长度为 <code>n</code>&nbsp;的字符串。</p>
<p>假如在该字符串中,这四个字符都恰好出现&nbsp;<code>n/4</code>&nbsp;次,那么它就是一个「平衡字符串」。</p>
<p>&nbsp;</p>
<p>给你一个这样的字符串 <code>s</code>,请通过「替换一个子串」的方式,使原字符串 <code>s</code> 变成一个「平衡字符串」。</p>
<p>你可以用和「待替换子串」长度相同的&nbsp;<strong>任何</strong> 其他字符串来完成替换。</p>
<p>请返回待替换子串的最小可能长度。</p>
<p>如果原字符串自身就是一个平衡字符串,则返回 <code>0</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;QWER&quot;
<strong>输出:</strong>0
<strong>解释:</strong>s 已经是平衡的了。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;QQWE&quot;
<strong>输出:</strong>1
<strong>解释:</strong>我们需要把一个 &#39;Q&#39; 替换成 &#39;R&#39;,这样得到的 &quot;RQWE&quot; (或 &quot;QRWE&quot;) 是平衡的。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;QQQW&quot;
<strong>输出:</strong>2
<strong>解释:</strong>我们可以把前面的 &quot;QQ&quot; 替换成 &quot;ER&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;QQQQ&quot;
<strong>输出:</strong>3
<strong>解释:</strong>我们可以替换后 3 个 &#39;Q&#39;,使 s = &quot;QWER&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s.length</code>&nbsp;&nbsp;<code>4</code>&nbsp;的倍数</li>
<li><code>s</code>&nbsp;中只含有&nbsp;<code>&#39;Q&#39;</code>, <code>&#39;W&#39;</code>, <code>&#39;E&#39;</code>,&nbsp;<code>&#39;R&#39;</code>&nbsp;四种字符</li>
</ul>
<p>你打算利用空闲时间来做兼职工作赚些零花钱。</p>
<p>这里有&nbsp;<code>n</code>&nbsp;份兼职工作,每份工作预计从&nbsp;<code>startTime[i]</code>&nbsp;开始到&nbsp;<code>endTime[i]</code>&nbsp;结束,报酬为&nbsp;<code>profit[i]</code></p>
<p>给你一份兼职工作表,包含开始时间&nbsp;<code>startTime</code>,结束时间&nbsp;<code>endTime</code>&nbsp;和预计报酬&nbsp;<code>profit</code>&nbsp;三个数组,请你计算并返回可以获得的最大报酬。</p>
<p>注意,时间上出现重叠的 2 份工作不能同时进行。</p>
<p>如果你选择的工作在时间&nbsp;<code>X</code>&nbsp;结束,那么你可以立刻进行在时间&nbsp;<code>X</code>&nbsp;开始的下一份工作。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/19/sample1_1584.png" style="width: 300px;"></strong></p>
<pre><strong>输入:</strong>startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
<strong>输出:</strong>120
<strong>解释:
</strong>我们选出第 1 份和第 4 份工作,
时间范围是 [1-3]+[3-6],共获得报酬 120 = 50 + 70。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/19/sample22_1584.png" style="height: 112px; width: 600px;"> </strong></p>
<pre><strong>输入:</strong>startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
<strong>输出:</strong>150
<strong>解释:
</strong>我们选择第 1,4,5 份工作。
共获得报酬 150 = 20 + 70 + 60。
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/19/sample3_1584.png" style="height: 112px; width: 400px;"></strong></p>
<pre><strong>输入:</strong>startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
<strong>输出:</strong>6
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= startTime.length == endTime.length ==&nbsp;profit.length&nbsp;&lt;= 5 * 10^4</code></li>
<li><code>1 &lt;=&nbsp;startTime[i] &lt;&nbsp;endTime[i] &lt;= 10^9</code></li>
<li><code>1 &lt;=&nbsp;profit[i] &lt;= 10^4</code></li>
</ul>
<p>给你一个函数  <code>f(x, y)</code> 和一个目标结果 <code>z</code>,函数公式未知,请你计算方程 <code>f(x,y) == z</code> 所有可能的正整数 <strong>数对</strong> <code>x</code><code>y</code>。满足条件的结果数对可以按任意顺序返回。</p>
<p>尽管函数的具体式子未知,但它是单调递增函数,也就是说:</p>
<ul>
<li><code>f(x, y) < f(x + 1, y)</code></li>
<li><code>f(x, y) < f(x, y + 1)</code></li>
</ul>
<p>函数接口定义如下:</p>
<pre>
interface CustomFunction {
public:
// Returns some positive integer f(x, y) for two positive integers x and y based on a formula.
int f(int x, int y);
};</pre>
<p>你的解决方案将按如下规则进行评判:</p>
<ul>
<li>判题程序有一个由 <code>CustomFunction</code><code>9</code> 种实现组成的列表,以及一种为特定的 <code>z</code> 生成所有有效数对的答案的方法。</li>
<li>判题程序接受两个输入:<code>function_id</code>(决定使用哪种实现测试你的代码)以及目标结果 <code>z</code></li>
<li>判题程序将会调用你实现的 <code>findSolution</code> 并将你的结果与答案进行比较。</li>
<li>如果你的结果与答案相符,那么解决方案将被视作正确答案,即 <code>Accepted</code></li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>function_id = 1, z = 5
<strong>输出:</strong>[[1,4],[2,3],[3,2],[4,1]]
<strong>解释:</strong>function_id = 1 暗含的函数式子为 f(x, y) = x + y
以下 x 和 y 满足 f(x, y) 等于 5:
x=1, y=4 -> f(1, 4) = 1 + 4 = 5
x=2, y=3 -> f(2, 3) = 2 + 3 = 5
x=3, y=2 -> f(3, 2) = 3 + 2 = 5
x=4, y=1 -> f(4, 1) = 4 + 1 = 5
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>function_id = 2, z = 5
<strong>输出:</strong>[[1,5],[5,1]]
<strong>解释:</strong>function_id = 2 暗含的函数式子为 f(x, y) = x * y
以下 x 和 y 满足 f(x, y) 等于 5:
x=1, y=5 -> f(1, 5) = 1 * 5 = 5
x=5, y=1 -> f(5, 1) = 5 * 1 = 5</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= function_id <= 9</code></li>
<li><code>1 <= z <= 100</code></li>
<li>题目保证 <code>f(x, y) == z</code> 的解处于 <code>1 <= x, y <= 1000</code> 的范围内。</li>
<li><code>1 <= x, y <= 1000</code> 的前提下,题目保证 <code>f(x, y)</code> 是一个 32 位有符号整数。</li>
</ul>
<p>给你两个整数&nbsp;<code>n</code><code>start</code>。你的任务是返回任意 <code>(0,1,2,,...,2^n-1)</code> 的排列 <code>p</code>,并且满足:</p>
<ul>
<li><code>p[0] = start</code></li>
<li><code>p[i]</code><code>p[i+1]</code>&nbsp;的二进制表示形式只有一位不同</li>
<li><code>p[0]</code><code>p[2^n -1]</code>&nbsp;的二进制表示形式也只有一位不同</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 2, start = 3
<strong>输出:</strong>[3,2,0,1]
<strong>解释:</strong>这个排列的二进制表示是 (11,10,00,01)
所有的相邻元素都有一位是不同的,另一个有效的排列是 [3,1,0,2]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输出:</strong>n = 3, start = 2
<strong>输出:</strong>[2,6,7,5,4,0,1,3]
<strong>解释:</strong>这个排列的二进制表示是 (010,110,111,101,100,000,001,011)
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 16</code></li>
<li><code>0 &lt;= start&nbsp;&lt;&nbsp;2^n</code></li>
</ul>
<p>给定一个字符串数组 <code>arr</code>,字符串 <code>s</code> 是将 <code>arr</code> 某一子序列字符串连接所得的字符串,如果 <code>s</code> 中的每一个字符都只出现过一次,那么它就是一个可行解。</p>
<p>请返回所有可行解 <code>s</code> 中最长长度。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [&quot;un&quot;,&quot;iq&quot;,&quot;ue&quot;]
<strong>输出:</strong>4
<strong>解释:</strong>所有可能的串联组合是 &quot;&quot;,&quot;un&quot;,&quot;iq&quot;,&quot;ue&quot;,&quot;uniq&quot;&quot;ique&quot;,最大长度为 4。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [&quot;cha&quot;,&quot;r&quot;,&quot;act&quot;,&quot;ers&quot;]
<strong>输出:</strong>6
<strong>解释:</strong>可能的解答有 &quot;chaers&quot;&quot;acters&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [&quot;abcdefghijklmnopqrstuvwxyz&quot;]
<strong>输出:</strong>26
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 16</code></li>
<li><code>1 &lt;= arr[i].length &lt;= 26</code></li>
<li><code>arr[i]</code>&nbsp;中只含有小写英文字母</li>
</ul>
<p>你是一位施工队的工长,根据设计师的要求准备为一套设计风格独特的房子进行室内装修。</p>
<p>房子的客厅大小为&nbsp;<code>n</code>&nbsp;x <code>m</code>,为保持极简的风格,需要使用尽可能少的 <strong>正方形</strong> 瓷砖来铺盖地面。</p>
<p>假设正方形瓷砖的规格不限,边长都是整数。</p>
<p>请你帮设计师计算一下,最少需要用到多少块方形瓷砖?</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/25/sample_11_1592.png" style="height: 106px; width: 154px;"></p>
<pre><strong>输入:</strong>n = 2, m = 3
<strong>输出:</strong>3
<code><strong>解释:</strong>3</code> 块地砖就可以铺满卧室。
<code> 2</code><code>1x1 地砖</code>
<code> 1</code><code>2x2 地砖</code></pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/25/sample_22_1592.png" style="height: 126px; width: 224px;"></p>
<pre><strong>输入:</strong>n = 5, m = 8
<strong>输出:</strong>5
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/10/25/sample_33_1592.png" style="height: 189px; width: 224px;"></p>
<pre><strong>输入:</strong>n = 11, m = 13
<strong>输出:</strong>6
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 13</code></li>
<li><code>1 &lt;= m&nbsp;&lt;=&nbsp;13</code></li>
</ul>
<p>有两个长度相同的字符串&nbsp;<code>s1</code>&nbsp;<code>s2</code>,且它们其中&nbsp;<strong>只含有</strong>&nbsp;字符&nbsp;<code>&quot;x&quot;</code>&nbsp;<code>&quot;y&quot;</code>,你需要通过「交换字符」的方式使这两个字符串相同。</p>
<p>每次「交换字符」的时候,你都可以在两个字符串中各选一个字符进行交换。</p>
<p>交换只能发生在两个不同的字符串之间,绝对不能发生在同一个字符串内部。也就是说,我们可以交换&nbsp;<code>s1[i]</code>&nbsp;<code>s2[j]</code>,但不能交换&nbsp;<code>s1[i]</code>&nbsp;<code>s1[j]</code></p>
<p>最后,请你返回使 <code>s1</code><code>s2</code> 相同的最小交换次数,如果没有方法能够使得这两个字符串相同,则返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;xx&quot;, s2 = &quot;yy&quot;
<strong>输出:</strong>1
<strong>解释:
</strong>交换 s1[0] 和 s2[1],得到 s1 = &quot;yx&quot;,s2 = &quot;yx&quot;</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;xy&quot;, s2 = &quot;yx&quot;
<strong>输出:</strong>2
<strong>解释:
</strong>交换 s1[0] 和 s2[0],得到 s1 = &quot;yy&quot;,s2 = &quot;xx&quot;
交换 s1[0] 和 s2[1],得到 s1 = &quot;xy&quot;,s2 = &quot;xy&quot;
注意,你不能交换 s1[0] 和 s1[1] 使得 s1 变成 &quot;yx&quot;,因为我们只能交换属于两个不同字符串的字符。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;xx&quot;, s2 = &quot;xy&quot;
<strong>输出:</strong>-1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;xxyyxyxyxx&quot;, s2 = &quot;xyyxyxxxyx&quot;
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s1.length, s2.length &lt;= 1000</code></li>
<li><code>s1, s2</code>&nbsp;只包含&nbsp;<code>&#39;x&#39;</code>&nbsp;&nbsp;<code>&#39;y&#39;</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code> 和一个整数 <code>k</code></p>
<p>如果某个 <strong>连续</strong> 子数组中恰好有 <code>k</code> 个奇数数字,我们就认为这个子数组是「<strong>优美子数组</strong>」。</p>
<p>请返回这个数组中「优美子数组」的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,2,1,1], k = 3
<strong>输出:</strong>2
<strong>解释:</strong>包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [2,4,6], k = 1
<strong>输出:</strong>0
<strong>解释:</strong>数列中不包含任何奇数,所以不存在优美子数组。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [2,2,2,1,2,2,1,2,2,2], k = 2
<strong>输出:</strong>16
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 50000</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^5</code></li>
<li><code>1 &lt;= k &lt;= nums.length</code></li>
</ul>
<p>给你一个由 <code>&#39;(&#39;</code><code>&#39;)&#39;</code> 和小写字母组成的字符串 <code>s</code></p>
<p>你需要从字符串中删除最少数目的 <code>&#39;(&#39;</code> 或者 <code>&#39;)&#39;</code>&nbsp;(可以删除任意位置的括号),使得剩下的「括号字符串」有效。</p>
<p>请返回任意一个合法字符串。</p>
<p>有效「括号字符串」应当符合以下&nbsp;<strong>任意一条&nbsp;</strong>要求:</p>
<ul>
<li>空字符串或只包含小写字母的字符串</li>
<li>可以被写作&nbsp;<code>AB</code><code>A</code>&nbsp;连接&nbsp;<code>B</code>)的字符串,其中&nbsp;<code>A</code>&nbsp;&nbsp;<code>B</code>&nbsp;都是有效「括号字符串」</li>
<li>可以被写作&nbsp;<code>(A)</code>&nbsp;的字符串,其中&nbsp;<code>A</code>&nbsp;是一个有效的「括号字符串」</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;lee(t(c)o)de)&quot;
<strong>输出:</strong>&quot;lee(t(c)o)de&quot;
<strong>解释:</strong>&quot;lee(t(co)de)&quot; , &quot;lee(t(c)ode)&quot; 也是一个可行答案。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;a)b(c)d&quot;
<strong>输出:</strong>&quot;ab(c)d&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;))((&quot;
<strong>输出:</strong>&quot;&quot;
<strong>解释:</strong>空字符串也是有效的
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;(a(b(c)d)&quot;
<strong>输出:</strong>&quot;a(b(c)d)&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s[i]</code>&nbsp;可能是&nbsp;<code>&#39;(&#39;</code><code>&#39;)&#39;</code>&nbsp;或英文小写字母</li>
</ul>
<p>给你一个正整数数组 <code>nums</code>,你需要从中任选一些子集,然后将子集中每一个数乘以一个 <strong>任意整数</strong>,并求出他们的和。</p>
<p>假如该和结果为&nbsp;<code>1</code>,那么原数组就是一个「<strong>好数组</strong>」,则返回 <code>True</code>;否则请返回 <code>False</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [12,5,7,23]
<strong>输出:</strong>true
<strong>解释:</strong>挑选数字 5 和 7。
5*3 + 7*(-2) = 1
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [29,6,10]
<strong>输出:</strong>true
<strong>解释:</strong>挑选数字 29, 6 和 10。
29*1 + 6*(-3) + 10*(-1) = 1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [3,6]
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^9</code></li>
</ul>
<p>给你一个 <code>m x n</code> 的矩阵,最开始的时候,每个单元格中的值都是 <code>0</code></p>
<p>另有一个二维索引数组 <code>indices</code><code>indices[i] = [ri, ci]</code> 指向矩阵中的某个位置,其中 <code>ri</code><code>ci</code> 分别表示指定的行和列(<strong><code>0</code> 开始编号</strong>)。</p>
<p><code>indices[i]</code> 所指向的每个位置,应同时执行下述增量操作:</p>
<ol>
<li><code>r<sub>i</sub></code> 行上的所有单元格,加 <code>1</code></li>
<li><code>c<sub>i</sub></code> 列上的所有单元格,加 <code>1</code></li>
</ol>
<p>给你 <code>m</code><code>n</code><code>indices</code> 。请你在执行完所有 <code>indices</code> 指定的增量操作后,返回矩阵中 <strong>奇数值单元格</strong> 的数目。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/06/e1.png" style="height: 118px; width: 600px;" /></p>
<pre>
<strong>输入:</strong>m = 2, n = 3, indices = [[0,1],[1,1]]
<strong>输出:</strong>6
<strong>解释:</strong>最开始的矩阵是 [[0,0,0],[0,0,0]]。
第一次增量操作后得到 [[1,2,1],[0,1,0]]。
最后的矩阵是 [[1,3,1],[1,3,1]],里面有 6 个奇数。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/06/e2.png" style="height: 150px; width: 600px;" /></p>
<pre>
<strong>输入:</strong>m = 2, n = 2, indices = [[1,1],[0,0]]
<strong>输出:</strong>0
<strong>解释:</strong>最后的矩阵是 [[2,2],[2,2]],里面没有奇数。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= m, n <= 50</code></li>
<li><code>1 <= indices.length <= 100</code></li>
<li><code>0 <= r<sub>i</sub> < m</code></li>
<li><code>0 <= c<sub>i</sub> < n</code></li>
</ul>
<p> </p>
<p><strong>进阶:</strong>你可以设计一个时间复杂度为 <code>O(n + m + indices.length)</code> 且仅用 <code>O(n + m)</code> 额外空间的算法来解决此问题吗?</p>
<p>给你一个&nbsp;<code>2</code>&nbsp;<code>n</code> 列的二进制数组:</p>
<ul>
<li>矩阵是一个二进制矩阵,这意味着矩阵中的每个元素不是&nbsp;<code>0</code>&nbsp;就是&nbsp;<code>1</code></li>
<li><code>0</code> 行的元素之和为&nbsp;<code>upper</code></li>
<li><code>1</code> 行的元素之和为 <code>lower</code></li>
<li><code>i</code> 列(从 <code>0</code> 开始编号)的元素之和为&nbsp;<code>colsum[i]</code><code>colsum</code>&nbsp;是一个长度为&nbsp;<code>n</code>&nbsp;的整数数组。</li>
</ul>
<p>你需要利用&nbsp;<code>upper</code><code>lower</code>&nbsp;&nbsp;<code>colsum</code>&nbsp;来重构这个矩阵,并以二维整数数组的形式返回它。</p>
<p>如果有多个不同的答案,那么任意一个都可以通过本题。</p>
<p>如果不存在符合要求的答案,就请返回一个空的二维数组。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>upper = 2, lower = 1, colsum = [1,1,1]
<strong>输出:</strong>[[1,1,0],[0,0,1]]
<strong>解释:</strong>[[1,0,1],[0,1,0]] 和 [[0,1,1],[1,0,0]] 也是正确答案。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>upper = 2, lower = 3, colsum = [2,2,1,1]
<strong>输出:</strong>[]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]
<strong>输出:</strong>[[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= colsum.length &lt;= 10^5</code></li>
<li><code>0 &lt;= upper, lower &lt;= colsum.length</code></li>
<li><code>0 &lt;= colsum[i] &lt;= 2</code></li>
</ul>
<p>有一个二维矩阵 <code>grid</code>&nbsp;,每个位置要么是陆地(记号为&nbsp;<code>0</code> )要么是水域(记号为&nbsp;<code>1</code> )。</p>
<p>我们从一块陆地出发,每次可以往上下左右&nbsp;4 个方向相邻区域走,能走到的所有陆地区域,我们将其称为一座「<strong>岛屿</strong>」。</p>
<p>如果一座岛屿&nbsp;<strong>完全</strong>&nbsp;由水域包围,即陆地边缘上下左右所有相邻区域都是水域,那么我们将其称为 「<strong>封闭岛屿</strong>」。</p>
<p>请返回封闭岛屿的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/07/sample_3_1610.png"></p>
<pre><strong>输入:</strong>grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
<strong>输出:</strong>2
<strong>解释:</strong>
灰色区域的岛屿是封闭岛屿,因为这座岛屿完全被水域包围(即被 1 区域包围)。</pre>
<p><strong>示例 2:</strong></p>
<p><img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/07/sample_4_1610.png"></p>
<pre><strong>输入:</strong>grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
<strong>输出:</strong>1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1,1,1,1,1,1],
&nbsp; [1,0,0,0,0,0,1],
&nbsp; [1,0,1,1,1,0,1],
&nbsp; [1,0,1,0,1,0,1],
&nbsp; [1,0,1,1,1,0,1],
&nbsp; [1,0,0,0,0,0,1],
[1,1,1,1,1,1,1]]
<strong>输出:</strong>2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= grid.length, grid[0].length &lt;= 100</code></li>
<li><code>0 &lt;= grid[i][j] &lt;=1</code></li>
</ul>
<p>你将会得到一份单词表&nbsp;<code>words</code>,一个字母表&nbsp;<code>letters</code>&nbsp;(可能会有重复字母),以及每个字母对应的得分情况表&nbsp;<code>score</code></p>
<p>请你帮忙计算玩家在单词拼写游戏中所能获得的「最高得分」:能够由&nbsp;<code>letters</code>&nbsp;里的字母拼写出的&nbsp;<strong>任意</strong>&nbsp;属于 <code>words</code>&nbsp;单词子集中,分数最高的单词集合的得分。</p>
<p>单词拼写游戏的规则概述如下:</p>
<ul>
<li>玩家需要用字母表&nbsp;<code>letters</code> 里的字母来拼写单词表&nbsp;<code>words</code>&nbsp;中的单词。</li>
<li>可以只使用字母表&nbsp;<code>letters</code> 中的部分字母,但是每个字母最多被使用一次。</li>
<li>单词表 <code>words</code>&nbsp;中每个单词只能计分(使用)一次。</li>
<li>根据字母得分情况表<code>score</code>,字母 <code>&#39;a&#39;</code>,&nbsp;<code>&#39;b&#39;</code>,&nbsp;<code>&#39;c&#39;</code>, ... ,&nbsp;<code>&#39;z&#39;</code> 对应的得分分别为 <code>score[0]</code>, <code>score[1]</code>,&nbsp;...,&nbsp;<code>score[25]</code></li>
<li>本场游戏的「得分」是指:玩家所拼写出的单词集合里包含的所有字母的得分之和。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>words = [&quot;dog&quot;,&quot;cat&quot;,&quot;dad&quot;,&quot;good&quot;], letters = [&quot;a&quot;,&quot;a&quot;,&quot;c&quot;,&quot;d&quot;,&quot;d&quot;,&quot;d&quot;,&quot;g&quot;,&quot;o&quot;,&quot;o&quot;], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
<strong>输出:</strong>23
<strong>解释:</strong>
字母得分为 a=1, c=9, d=5, g=3, o=2
使用给定的字母表 letters,我们可以拼写单词 &quot;dad&quot; (5+1+5)和 &quot;good&quot; (3+2+2+5),得分为 23 。
而单词 &quot;dad&quot;&quot;dog&quot; 只能得到 21 分。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>words = [&quot;xxxz&quot;,&quot;ax&quot;,&quot;bx&quot;,&quot;cx&quot;], letters = [&quot;z&quot;,&quot;a&quot;,&quot;b&quot;,&quot;c&quot;,&quot;x&quot;,&quot;x&quot;,&quot;x&quot;], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
<strong>输出:</strong>27
<strong>解释:</strong>
字母得分为 a=4, b=4, c=4, x=5, z=10
使用给定的字母表 letters,我们可以组成单词 &quot;ax&quot; (4+5), &quot;bx&quot; (4+5) 和 &quot;cx&quot; (4+5) ,总得分为 27 。
单词 &quot;xxxz&quot; 的得分仅为 25 。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>words = [&quot;leetcode&quot;], letters = [&quot;l&quot;,&quot;e&quot;,&quot;t&quot;,&quot;c&quot;,&quot;o&quot;,&quot;d&quot;], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
<strong>输出:</strong>0
<strong>解释:</strong>
字母 &quot;e&quot; 在字母表 letters 中只出现了一次,所以无法组成单词表 words 中的单词。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= words.length &lt;= 14</code></li>
<li><code>1 &lt;= words[i].length &lt;= 15</code></li>
<li><code>1 &lt;= letters.length &lt;= 100</code></li>
<li><code>letters[i].length == 1</code></li>
<li><code>score.length ==&nbsp;26</code></li>
<li><code>0 &lt;= score[i] &lt;= 10</code></li>
<li><code>words[i]</code>&nbsp;&nbsp;<code>letters[i]</code>&nbsp;只包含小写的英文字母。</li>
</ul>
<p>给你一个 <code>m</code><code>n</code> 列的二维网格 <code>grid</code> 和一个整数 <code>k</code>。你需要将 <code>grid</code> 迁移 <code>k</code> 次。</p>
<p>每次「迁移」操作将会引发下述活动:</p>
<ul>
<li>位于 <code>grid[i][j]</code> 的元素将会移动到 <code>grid[i][j + 1]</code></li>
<li>位于 <code>grid[i][n - 1]</code> 的元素将会移动到 <code>grid[i + 1][0]</code></li>
<li>位于 <code>grid[m - 1][n - 1]</code> 的元素将会移动到 <code>grid[0][0]</code></li>
</ul>
<p>请你返回 <code>k</code> 次迁移操作后最终得到的 <strong>二维网格</strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/16/e1-1.png" style="height: 158px; width: 400px;" /></p>
<pre>
<code><strong>输入:</strong>grid</code> = [[1,2,3],[4,5,6],[7,8,9]], k = 1
<strong>输出:</strong>[[9,1,2],[3,4,5],[6,7,8]]
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/16/e2-1.png" style="height: 166px; width: 400px;" /></p>
<pre>
<code><strong>输入:</strong>grid</code> = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4
<strong>输出:</strong>[[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<code><strong>输入:</strong>grid</code> = [[1,2,3],[4,5,6],[7,8,9]], k = 9
<strong>输出:</strong>[[1,2,3],[4,5,6],[7,8,9]]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == grid.length</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>1 <= m <= 50</code></li>
<li><code>1 <= n <= 50</code></li>
<li><code>-1000 <= grid[i][j] <= 1000</code></li>
<li><code>0 <= k <= 100</code></li>
</ul>
<p>按字典 <code>wordList</code> 完成从单词 <code>beginWord</code> 到单词 <code>endWord</code> 转化,一个表示此过程的 <strong>转换序列</strong> 是形式上像 <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> 这样的单词序列,并满足:</p>
<div class="original__bRMd">
<div>
<ul>
<li>每对相邻的单词之间仅有单个字母不同。</li>
<li>转换过程中的每个单词 <code>s<sub>i</sub></code><code>1 <= i <= k</code>)必须是字典 <code>wordList</code> 中的单词。注意,<code>beginWord</code> 不必是字典 <code>wordList</code> 中的单词。</li>
<li><code>s<sub>k</sub> == endWord</code></li>
</ul>
<p>给你两个单词 <code>beginWord</code><code>endWord</code> ,以及一个字典 <code>wordList</code> 。请你找出并返回所有从 <code>beginWord</code><code>endWord</code><strong>最短转换序列</strong> ,如果不存在这样的转换序列,返回一个空列表。每个序列都应该以单词列表<em> </em><code>[beginWord, s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub>]</code> 的形式返回。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
<strong>输出:</strong>[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
<strong>解释:</strong>存在 2 种最短的转换序列:
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
"hit" -> "hot" -> "lot" -> "log" -> "cog"
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
<strong>输出:</strong>[]
<strong>解释:</strong>endWord "cog" 不在字典 wordList 中,所以不存在符合要求的转换序列。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= beginWord.length <= 7</code></li>
<li><code>endWord.length == beginWord.length</code></li>
<li><code>1 <= wordList.length <= 5000</code></li>
<li><code>wordList[i].length == beginWord.length</code></li>
<li><code>beginWord</code><code>endWord</code><code>wordList[i]</code> 由小写英文字母组成</li>
<li><code>beginWord != endWord</code></li>
<li><code>wordList</code> 中的所有单词 <strong>互不相同</strong></li>
</ul>
</div>
</div>
<p>给出一个满足下述规则的二叉树:</p>
<ol>
<li><code>root.val == 0</code></li>
<li>如果 <code>treeNode.val == x</code>&nbsp;<code>treeNode.left != null</code>,那么&nbsp;<code>treeNode.left.val == 2 * x + 1</code></li>
<li>如果 <code>treeNode.val == x</code><code>treeNode.right != null</code>,那么&nbsp;<code>treeNode.right.val == 2 * x + 2</code></li>
</ol>
<p>现在这个二叉树受到「污染」,所有的&nbsp;<code>treeNode.val</code>&nbsp;都变成了&nbsp;<code>-1</code></p>
<p>请你先还原二叉树,然后实现&nbsp;<code>FindElements</code>&nbsp;类:</p>
<ul>
<li><code>FindElements(TreeNode* root)</code>&nbsp;用受污染的二叉树初始化对象,你需要先把它还原。</li>
<li><code>bool find(int target)</code>&nbsp;判断目标值&nbsp;<code>target</code>&nbsp;是否存在于还原后的二叉树中并返回结果。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/16/untitled-diagram-4-1.jpg" style="height: 119px; width: 320px;"></strong></p>
<pre><strong>输入:</strong>
[&quot;FindElements&quot;,&quot;find&quot;,&quot;find&quot;]
[[[-1,null,-1]],[1],[2]]
<strong>输出:</strong>
[null,false,true]
<strong>解释:</strong>
FindElements findElements = new FindElements([-1,null,-1]);
findElements.find(1); // return False
findElements.find(2); // return True </pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/16/untitled-diagram-4.jpg" style="height: 198px; width: 400px;"></strong></p>
<pre><strong>输入:</strong>
[&quot;FindElements&quot;,&quot;find&quot;,&quot;find&quot;,&quot;find&quot;]
[[[-1,-1,-1,-1,-1]],[1],[3],[5]]
<strong>输出:</strong>
[null,true,true,false]
<strong>解释:</strong>
FindElements findElements = new FindElements([-1,-1,-1,-1,-1]);
findElements.find(1); // return True
findElements.find(3); // return True
findElements.find(5); // return False</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/16/untitled-diagram-4-1-1.jpg" style="height: 274px; width: 306px;"></strong></p>
<pre><strong>输入:</strong>
[&quot;FindElements&quot;,&quot;find&quot;,&quot;find&quot;,&quot;find&quot;,&quot;find&quot;]
[[[-1,null,-1,-1,null,-1]],[2],[3],[4],[5]]
<strong>输出:</strong>
[null,true,false,false,true]
<strong>解释:</strong>
FindElements findElements = new FindElements([-1,null,-1,-1,null,-1]);
findElements.find(2); // return True
findElements.find(3); // return False
findElements.find(4); // return False
findElements.find(5); // return True
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>TreeNode.val == -1</code></li>
<li>二叉树的高度不超过&nbsp;<code>20</code></li>
<li>节点的总数在&nbsp;<code>[1,&nbsp;10^4]</code>&nbsp;之间</li>
<li>调用&nbsp;<code>find()</code>&nbsp;的总次数在&nbsp;<code>[1,&nbsp;10^4]</code>&nbsp;之间</li>
<li><code>0 &lt;= target &lt;= 10^6</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code>,请你找出并返回能被三整除的元素最大和。</p>
<ol>
</ol>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [3,6,5,1,8]
<strong>输出:</strong>18
<strong>解释:</strong>选出数字 3, 6, 1 和 8,它们的和是 18(可被 3 整除的最大和)。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [4]
<strong>输出:</strong>0
<strong>解释:</strong>4 不能被 3 整除,所以无法选出数字,返回 0。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3,4,4]
<strong>输出:</strong>12
<strong>解释:</strong>选出数字 1, 3, 4 以及 4,它们的和是 12(可被 3 整除的最大和)。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 4 * 10^4</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^4</code></li>
</ul>
<p>「推箱子」是一款风靡全球的益智小游戏,玩家需要将箱子推到仓库中的目标位置。</p>
<p>游戏地图用大小为 <code>n * m</code> 的网格 <code>grid</code> 表示,其中每个元素可以是墙、地板或者是箱子。</p>
<p>现在你将作为玩家参与游戏,按规则将箱子&nbsp;<code>&#39;B&#39;</code>&nbsp;移动到目标位置&nbsp;<code>&#39;T&#39;</code></p>
<ul>
<li>玩家用字符&nbsp;<code>&#39;S&#39;</code>&nbsp;表示,只要他在地板上,就可以在网格中向上、下、左、右四个方向移动。</li>
<li>地板用字符&nbsp;<code>&#39;.&#39;</code>&nbsp;表示,意味着可以自由行走。</li>
<li>墙用字符&nbsp;<code>&#39;#&#39;</code>&nbsp;表示,意味着障碍物,不能通行。&nbsp;</li>
<li>箱子仅有一个,用字符&nbsp;<code>&#39;B&#39;</code>&nbsp;表示。相应地,网格上有一个目标位置&nbsp;<code>&#39;T&#39;</code></li>
<li>玩家需要站在箱子旁边,然后沿着箱子的方向进行移动,此时箱子会被移动到相邻的地板单元格。记作一次「推动」。</li>
<li>玩家无法越过箱子。</li>
</ul>
<p>返回将箱子推到目标位置的最小 <strong>推动</strong> 次数,如果无法做到,请返回&nbsp;<code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/16/sample_1_1620.png" style="height: 349px; width: 520px;"></strong></p>
<pre><strong>输入:</strong>grid = [[&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;],
[&quot;#&quot;,&quot;T&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;.&quot;,&quot;B&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;#&quot;,&quot;#&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;S&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;]]
<strong>输出:</strong>3
<strong>解释:</strong>我们只需要返回推箱子的次数。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>grid = [[&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;],
[&quot;#&quot;,&quot;T&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;.&quot;,&quot;B&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;S&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;]]
<strong>输出:</strong>-1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>grid = [[&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;T&quot;,&quot;.&quot;,&quot;.&quot;,&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;#&quot;,&quot;B&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;S&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;]]
<strong>输出:</strong>5
<strong>解释:</strong>向下、向左、向左、向上再向上。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>grid = [[&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;S&quot;,&quot;#&quot;,&quot;.&quot;,&quot;B&quot;,&quot;T&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;]]
<strong>输出:</strong>-1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= grid.length &lt;= 20</code></li>
<li><code>1 &lt;= grid[i].length &lt;= 20</code></li>
<li><code>grid</code> 仅包含字符&nbsp;<code>&#39;.&#39;</code>, <code>&#39;#&#39;</code>,&nbsp; <code>&#39;S&#39;</code> , <code>&#39;T&#39;</code>, 以及&nbsp;<code>&#39;B&#39;</code></li>
<li><code>grid</code>&nbsp;&nbsp;<code>&#39;S&#39;</code>, <code>&#39;B&#39;</code>&nbsp;&nbsp;<code>&#39;T&#39;</code>&nbsp;各只能出现一个。</li>
</ul>
<p>平面上有 <code>n</code> 个点,点的位置用整数坐标表示 <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> 。请你计算访问所有这些点需要的 <strong>最小时间</strong>(以秒为单位)。</p>
<p>你需要按照下面的规则在平面上移动:</p>
<ul>
<li>每一秒内,你可以:
<ul>
<li>沿水平方向移动一个单位长度,或者</li>
<li>沿竖直方向移动一个单位长度,或者</li>
<li>跨过对角线移动 <code>sqrt(2)</code> 个单位长度(可以看作在一秒内向水平和竖直方向各移动一个单位长度)。</li>
</ul>
</li>
<li>必须按照数组中出现的顺序来访问这些点。</li>
<li>在访问某个点时,可以经过该点后面出现的点,但经过的那些点不算作有效访问。</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/24/1626_example_1.png" style="height: 428px; width: 500px;" /></p>
<pre>
<strong>输入:</strong>points = [[1,1],[3,4],[-1,0]]
<strong>输出:</strong>7
<strong>解释:</strong>一条最佳的访问路径是: <strong>[1,1]</strong> -> [2,2] -> [3,3] -> <strong>[3,4] </strong>-> [2,3] -> [1,2] -> [0,1] -> <strong>[-1,0]</strong>
从 [1,1] 到 [3,4] 需要 3 秒
从 [3,4] 到 [-1,0] 需要 4 秒
一共需要 7 秒</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>points = [[3,2],[-2,2]]
<strong>输出:</strong>5
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>points.length == n</code></li>
<li><code>1 <= n <= 100</code></li>
<li><code>points[i].length == 2</code></li>
<li><code>-1000 <= points[i][0], points[i][1] <= 1000</code></li>
</ul>
<p>这里有一幅服务器分布图,服务器的位置标识在&nbsp;<code>m * n</code>&nbsp;的整数矩阵网格&nbsp;<code>grid</code>&nbsp;中,1 表示单元格上有服务器,0 表示没有。</p>
<p>如果两台服务器位于同一行或者同一列,我们就认为它们之间可以进行通信。</p>
<p>请你统计并返回能够与至少一台其他服务器进行通信的服务器的数量。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/24/untitled-diagram-6.jpg" style="height: 203px; width: 202px;"></p>
<pre><strong>输入:</strong>grid = [[1,0],[0,1]]
<strong>输出:</strong>0
<strong>解释:</strong>没有一台服务器能与其他服务器进行通信。</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/24/untitled-diagram-4-1.jpg" style="height: 203px; width: 203px;"></strong></p>
<pre><strong>输入:</strong>grid = [[1,0],[1,1]]
<strong>输出:</strong>3
<strong>解释:</strong>所有这些服务器都至少可以与一台别的服务器进行通信。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/11/24/untitled-diagram-1-3.jpg" style="height: 443px; width: 443px;"></p>
<pre><strong>输入:</strong>grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
<strong>输出:</strong>4
<strong>解释:</strong>第一行的两台服务器互相通信,第三列的两台服务器互相通信,但右下角的服务器无法与其他服务器通信。
</pre>
<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 &lt;= 250</code></li>
<li><code>1 &lt;= n &lt;= 250</code></li>
<li><code>grid[i][j] == 0 or 1</code></li>
</ul>
<p>给你一个产品数组&nbsp;<code>products</code>&nbsp;和一个字符串&nbsp;<code>searchWord</code>&nbsp;<code>products</code>&nbsp; 数组中每个产品都是一个字符串。</p>
<p>请你设计一个推荐系统,在依次输入单词&nbsp;<code>searchWord</code> 的每一个字母后,推荐&nbsp;<code>products</code> 数组中前缀与&nbsp;<code>searchWord</code> 相同的最多三个产品。如果前缀相同的可推荐产品超过三个,请按字典序返回最小的三个。</p>
<p>请你以二维列表的形式,返回在输入&nbsp;<code>searchWord</code>&nbsp;每个字母后相应的推荐产品的列表。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>products = [&quot;mobile&quot;,&quot;mouse&quot;,&quot;moneypot&quot;,&quot;monitor&quot;,&quot;mousepad&quot;], searchWord = &quot;mouse&quot;
<strong>输出:</strong>[
[&quot;mobile&quot;,&quot;moneypot&quot;,&quot;monitor&quot;],
[&quot;mobile&quot;,&quot;moneypot&quot;,&quot;monitor&quot;],
[&quot;mouse&quot;,&quot;mousepad&quot;],
[&quot;mouse&quot;,&quot;mousepad&quot;],
[&quot;mouse&quot;,&quot;mousepad&quot;]
]
<strong>解释:</strong>按字典序排序后的产品列表是 [&quot;mobile&quot;,&quot;moneypot&quot;,&quot;monitor&quot;,&quot;mouse&quot;,&quot;mousepad&quot;]
输入 m 和 mo,由于所有产品的前缀都相同,所以系统返回字典序最小的三个产品 [&quot;mobile&quot;,&quot;moneypot&quot;,&quot;monitor&quot;]
输入 mou, mous 和 mouse 后系统都返回 [&quot;mouse&quot;,&quot;mousepad&quot;]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>products = [&quot;havana&quot;], searchWord = &quot;havana&quot;
<strong>输出:</strong>[[&quot;havana&quot;],[&quot;havana&quot;],[&quot;havana&quot;],[&quot;havana&quot;],[&quot;havana&quot;],[&quot;havana&quot;]]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>products = [&quot;bags&quot;,&quot;baggage&quot;,&quot;banner&quot;,&quot;box&quot;,&quot;cloths&quot;], searchWord = &quot;bags&quot;
<strong>输出:</strong>[[&quot;baggage&quot;,&quot;bags&quot;,&quot;banner&quot;],[&quot;baggage&quot;,&quot;bags&quot;,&quot;banner&quot;],[&quot;baggage&quot;,&quot;bags&quot;],[&quot;bags&quot;]]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>products = [&quot;havana&quot;], searchWord = &quot;tatiana&quot;
<strong>输出:</strong>[[],[],[],[],[],[],[]]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= products.length &lt;= 1000</code></li>
<li><code>1 &lt;= &Sigma; products[i].length &lt;= 2 * 10^4</code></li>
<li><code>products[i]</code>&nbsp;中所有的字符都是小写英文字母。</li>
<li><code>1 &lt;= searchWord.length &lt;= 1000</code></li>
<li><code>searchWord</code>&nbsp;中所有字符都是小写英文字母。</li>
</ul>
<p>有一个长度为 <code>arrLen</code> 的数组,开始有一个指针在索引 <code>0</code> 处。</p>
<p>每一步操作中,你可以将指针向左或向右移动 1 步,或者停在原地(指针不能被移动到数组范围外)。</p>
<p>给你两个整数 <code>steps</code> 和 <code>arrLen</code> ,请你计算并返回:在恰好执行 <code>steps</code> 次操作以后,指针仍然指向索引 <code>0</code> 处的方案数。</p>
<p>由于答案可能会很大,请返回方案数 <strong></strong> <code>10^9 + 7</code> 后的结果。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>steps = 3, arrLen = 2
<strong>输出:</strong>4
<strong>解释:</strong>3 步后,总共有 4 种不同的方法可以停在索引 0 处。
向右,向左,不动
不动,向右,向左
向右,不动,向左
不动,不动,不动
</pre>
<p><strong>示例  2:</strong></p>
<pre>
<strong>输入:</strong>steps = 2, arrLen = 4
<strong>输出:</strong>2
<strong>解释:</strong>2 步后,总共有 2 种不同的方法可以停在索引 0 处。
向右,向左
不动,不动
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>steps = 4, arrLen = 2
<strong>输出:</strong>8
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= steps <= 500</code></li>
<li><code>1 <= arrLen <= 10<sup>6</sup></code></li>
</ul>
<p>字典 <code>wordList</code> 中从单词 <code>beginWord</code><em> </em><code>endWord</code><strong>转换序列 </strong>是一个按下述规格形成的序列:</p>
<ul>
<li>序列中第一个单词是 <code>beginWord</code></li>
<li>序列中最后一个单词是 <code>endWord</code></li>
<li>每次转换只能改变一个字母。</li>
<li>转换过程中的中间单词必须是字典 <code>wordList</code> 中的单词。</li>
</ul>
<p>给你两个单词<em> </em><code>beginWord</code><em> </em><code>endWord</code> 和一个字典 <code>wordList</code> ,找到从 <code>beginWord</code> 到 <code>endWord</code><strong>最短转换序列</strong> 中的 <strong>单词数目</strong> 。如果不存在这样的转换序列,返回 0。</p>
 
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
<strong>输出:</strong>5
<strong>解释:</strong>一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
<strong>输出:</strong>0
<strong>解释:</strong>endWord "cog" 不在字典中,所以无法进行转换。</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= beginWord.length <= 10</code></li>
<li><code>endWord.length == beginWord.length</code></li>
<li><code>1 <= wordList.length <= 5000</code></li>
<li><code>wordList[i].length == beginWord.length</code></li>
<li><code>beginWord</code><code>endWord</code><code>wordList[i]</code> 由小写英文字母组成</li>
<li><code>beginWord != endWord</code></li>
<li><code>wordList</code> 中的所有字符串 <strong>互不相同</strong></li>
</ul>
<p><em>A</em>&nbsp;<em>B</em>&nbsp;在一个&nbsp;<em>3</em>&nbsp;x&nbsp;<em>3</em>&nbsp;的网格上玩井字棋。</p>
<p>井字棋游戏的规则如下:</p>
<ul>
<li>玩家轮流将棋子放在空方格 (&quot; &quot;) 上。</li>
<li>第一个玩家 A 总是用&nbsp;&quot;X&quot; 作为棋子,而第二个玩家 B 总是用 &quot;O&quot; 作为棋子。</li>
<li>&quot;X&quot;&quot;O&quot; 只能放在空方格中,而不能放在已经被占用的方格上。</li>
<li>只要有 3 个相同的(非空)棋子排成一条直线(行、列、对角线)时,游戏结束。</li>
<li>如果所有方块都放满棋子(不为空),游戏也会结束。</li>
<li>游戏结束后,棋子无法再进行任何移动。</li>
</ul>
<p>给你一个数组 <code>moves</code>,其中每个元素是大小为 <code>2</code> 的另一个数组(元素分别对应网格的行和列),它按照 <em>A</em><em>B</em> 的行动顺序(先 <em>A</em><em>B</em>)记录了两人各自的棋子位置。</p>
<p>如果游戏存在获胜者(<em>A</em><em>B</em>),就返回该游戏的获胜者;如果游戏以平局结束,则返回 &quot;Draw&quot;;如果仍会有行动(游戏未结束),则返回 &quot;Pending&quot;</p>
<p>你可以假设&nbsp;<code>moves</code>&nbsp;<strong>有效</strong>(遵循井字棋规则),网格最初是空的,<em>A</em> 将先行动。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>moves = [[0,0],[2,0],[1,1],[2,1],[2,2]]
<strong>输出:</strong>&quot;A&quot;
<strong>解释:</strong>&quot;A&quot; 获胜,他总是先走。
&quot;X &quot; &quot;X &quot; &quot;X &quot; &quot;X &quot; &quot;<strong>X</strong> &quot;
&quot; &quot; -&gt; &quot; &quot; -&gt; &quot; X &quot; -&gt; &quot; X &quot; -&gt; &quot; <strong>X</strong> &quot;
&quot; &quot; &quot;O &quot; &quot;O &quot; &quot;OO &quot; &quot;OO<strong>X</strong>&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>moves = [[0,0],[1,1],[0,1],[0,2],[1,0],[2,0]]
<strong>输出:</strong>&quot;B&quot;
<strong>解释:</strong>&quot;B&quot; 获胜。
&quot;X &quot; &quot;X &quot; &quot;XX &quot; &quot;XXO&quot; &quot;XXO&quot; &quot;XX<strong>O</strong>&quot;
&quot; &quot; -&gt; &quot; O &quot; -&gt; &quot; O &quot; -&gt; &quot; O &quot; -&gt; &quot;XO &quot; -&gt; &quot;X<strong>O</strong> &quot;
&quot; &quot; &quot; &quot; &quot; &quot; &quot; &quot; &quot; &quot; &quot;<strong>O</strong> &quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>moves = [[0,0],[1,1],[2,0],[1,0],[1,2],[2,1],[0,1],[0,2],[2,2]]
<strong>输出:</strong>&quot;Draw&quot;
<strong>输出:</strong>由于没有办法再行动,游戏以平局结束。
&quot;XXO&quot;
&quot;OOX&quot;
&quot;XOX&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>moves = [[0,0],[1,1]]
<strong>输出:</strong>&quot;Pending&quot;
<strong>解释:</strong>游戏还没有结束。
&quot;X &quot;
&quot; O &quot;
&quot; &quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= moves.length &lt;= 9</code></li>
<li><code>moves[i].length == 2</code></li>
<li><code>0 &lt;= moves[i][j] &lt;= 2</code></li>
<li><code>moves</code>&nbsp;里没有重复的元素。</li>
<li><code>moves</code> 遵循井字棋的规则。</li>
</ul>
<p>圣诞活动预热开始啦,汉堡店推出了全新的汉堡套餐。为了避免浪费原料,请你帮他们制定合适的制作计划。</p>
<p>给你两个整数&nbsp;<code>tomatoSlices</code>&nbsp;&nbsp;<code>cheeseSlices</code>,分别表示番茄片和奶酪片的数目。不同汉堡的原料搭配如下:</p>
<ul>
<li><strong>巨无霸汉堡:</strong>4 片番茄和 1 片奶酪</li>
<li><strong>小皇堡:</strong>2 片番茄和&nbsp;1 片奶酪</li>
</ul>
<p>请你以&nbsp;<code>[total_jumbo, total_small]</code>([巨无霸汉堡总数,小皇堡总数])的格式返回恰当的制作方案,使得剩下的番茄片&nbsp;<code>tomatoSlices</code>&nbsp;和奶酪片&nbsp;<code>cheeseSlices</code>&nbsp;的数量都是&nbsp;<code>0</code></p>
<p>如果无法使剩下的番茄片&nbsp;<code>tomatoSlices</code>&nbsp;和奶酪片&nbsp;<code>cheeseSlices</code>&nbsp;的数量为&nbsp;<code>0</code>,就请返回&nbsp;<code>[]</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>tomatoSlices = 16, cheeseSlices = 7
<strong>输出:</strong>[1,6]
<strong>解释:</strong>制作 1 个巨无霸汉堡和 6 个小皇堡需要 4*1 + 2*6 = 16 片番茄和 1 + 6 = 7 片奶酪。不会剩下原料。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>tomatoSlices = 17, cheeseSlices = 4
<strong>输出:</strong>[]
<strong>解释:</strong>只制作小皇堡和巨无霸汉堡无法用光全部原料。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>tomatoSlices = 4, cheeseSlices = 17
<strong>输出:</strong>[]
<strong>解释:</strong>制作 1 个巨无霸汉堡会剩下 16 片奶酪,制作 2 个小皇堡会剩下 15 片奶酪。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>tomatoSlices = 0, cheeseSlices = 0
<strong>输出:</strong>[0,0]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>tomatoSlices = 2, cheeseSlices = 1
<strong>输出:</strong>[0,1]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 &lt;= tomatoSlices &lt;= 10^7</code></li>
<li><code>0 &lt;= cheeseSlices &lt;= 10^7</code></li>
</ul>
<p>给定一个未排序的整数数组 <code>nums</code> ,找出数字连续的最长序列(不要求序列元素在原数组中连续)的长度。</p>
<p>请你设计并实现时间复杂度为 <code>O(n)</code><em> </em>的算法解决此问题。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [100,4,200,1,3,2]
<strong>输出:</strong>4
<strong>解释:</strong>最长数字连续序列是 <code>[1, 2, 3, 4]。它的长度为 4。</code></pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [0,3,7,2,5,8,4,6,0,1]
<strong>输出:</strong>9
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 <= nums.length <= 10<sup>5</sup></code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code> 和一个正整数&nbsp;<code>threshold</code> &nbsp;,你需要选择一个正整数作为除数,然后将数组里每个数都除以它,并对除法结果求和。</p>
<p>请你找出能够使上述结果小于等于阈值&nbsp;<code>threshold</code>&nbsp;的除数中 <strong>最小</strong> 的那个。</p>
<p>每个数除以除数后都向上取整,比方说 7/3 = 3 , 10/2 = 5 。</p>
<p>题目保证一定有解。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,5,9], threshold = 6
<strong>输出:</strong>5
<strong>解释:</strong>如果除数为 1 ,我们可以得到和为 17 (1+2+5+9)。
如果除数为 4 ,我们可以得到和为 7 (1+1+2+3) 。如果除数为 5 ,和为 5 (1+1+1+2)。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [2,3,5,7,11], threshold = 11
<strong>输出:</strong>3
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>nums = [19], threshold = 5
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 5 * 10^4</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^6</code></li>
<li><code>nums.length &lt;=&nbsp;threshold &lt;= 10^6</code></li>
</ul>
<p>给你一个&nbsp;<code>m x n</code>&nbsp;的二进制矩阵&nbsp;<code>mat</code></p>
<p>每一步,你可以选择一个单元格并将它反转(反转表示 0 变 1 ,1 变 0 )。如果存在和它相邻的单元格,那么这些相邻的单元格也会被反转。(注:相邻的两个单元格共享同一条边。)</p>
<p>请你返回将矩阵&nbsp;<code>mat</code> 转化为全零矩阵的<em>最少反转次数</em>,如果无法转化为全零矩阵,请返回&nbsp;<strong>-1</strong>&nbsp;</p>
<p>二进制矩阵的每一个格子要么是 0 要么是 1 。</p>
<p>全零矩阵是所有格子都为 0 的矩阵。</p>
<p>&nbsp;</p>
<p><strong>示例&nbsp;1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/12/13/matrix.png" style="height: 86px; width: 409px;"></p>
<pre><strong>输入:</strong>mat = [[0,0],[0,1]]
<strong>输出:</strong>3
<strong>解释:</strong>一个可能的解是反转 (1, 0),然后 (0, 1) ,最后是 (1, 1) 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>mat = [[0]]
<strong>输出:</strong>0
<strong>解释:</strong>给出的矩阵是全零矩阵,所以你不需要改变它。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>mat = [[1,1,1],[1,0,1],[0,0,0]]
<strong>输出:</strong>6
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>mat = [[1,0,0],[1,0,0]]
<strong>输出:</strong>-1
<strong>解释:</strong>该矩阵无法转变成全零矩阵
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m ==&nbsp;mat.length</code></li>
<li><code>n ==&nbsp;mat[0].length</code></li>
<li><code>1 &lt;= m&nbsp;&lt;= 3</code></li>
<li><code>1 &lt;= n&nbsp;&lt;= 3</code></li>
<li><code>mat[i][j]</code>&nbsp;是 0 或 1 。</li>
</ul>
<p>请你设计一个迭代器类,包括以下内容:</p>
<ul>
<li>一个构造函数,输入参数包括:一个&nbsp;<strong>有序且字符唯一&nbsp;</strong>的字符串&nbsp;<code>characters</code>(该字符串只包含小写英文字母)和一个数字&nbsp;<code>combinationLength</code>&nbsp;</li>
<li>函数&nbsp;<em>next()&nbsp;</em>,按&nbsp;<strong>字典序&nbsp;</strong>返回长度为&nbsp;<code>combinationLength</code> 的下一个字母组合。</li>
<li>函数&nbsp;<em>hasNext()&nbsp;</em>,只有存在长度为&nbsp;<code>combinationLength</code> 的下一个字母组合时,才返回&nbsp;<code>True</code>;否则,返回 <code>False</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre>CombinationIterator iterator = new CombinationIterator(&quot;abc&quot;, 2); // 创建迭代器 iterator
iterator.next(); // 返回 &quot;ab&quot;
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 &quot;ac&quot;
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 &quot;bc&quot;
iterator.hasNext(); // 返回 false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= combinationLength &lt;=&nbsp;characters.length &lt;= 15</code></li>
<li>每组测试数据最多包含&nbsp;<code>10^4</code>&nbsp;次函数调用。</li>
<li>题目保证每次调用函数&nbsp;<code>next</code>&nbsp;时都存在下一个字母组合。</li>
</ul>
<p>给你一个非递减的&nbsp;<strong>有序&nbsp;</strong>整数数组,已知这个数组中恰好有一个整数,它的出现次数超过数组元素总数的 25%。</p>
<p>请你找到并返回这个整数</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,2,2,6,6,6,6,7,10]
<strong>输出:</strong>6
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^4</code></li>
<li><code>0 &lt;= arr[i] &lt;= 10^5</code></li>
</ul>
<p>给你一个区间列表,请你删除列表中被其他区间所覆盖的区间。</p>
<p>只有当&nbsp;<code>c &lt;= a</code>&nbsp;&nbsp;<code>b &lt;= d</code>&nbsp;时,我们才认为区间&nbsp;<code>[a,b)</code> 被区间&nbsp;<code>[c,d)</code> 覆盖。</p>
<p>在完成所有删除操作后,请你返回列表中剩余区间的数目。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入:</strong>intervals = [[1,4],[3,6],[2,8]]
<strong>输出:</strong>2
<strong>解释:</strong>区间 [3,6] 被区间 [2,8] 覆盖,所以它被删除了。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong>​​​​​​</p>
<ul>
<li><code>1 &lt;= intervals.length &lt;= 1000</code></li>
<li><code>0 &lt;= intervals[i][0] &lt;&nbsp;intervals[i][1] &lt;= 10^5</code></li>
<li>对于所有的&nbsp;<code>i != j</code><code>intervals[i] != intervals[j]</code></li>
</ul>
<p>给你一个整数方阵&nbsp;<code>arr</code>&nbsp;,定义「非零偏移下降路径」为:从&nbsp;<code>arr</code> 数组中的每一行选择一个数字,且按顺序选出来的数字中,相邻数字不在原数组的同一列。</p>
<p>请你返回非零偏移下降路径数字和的最小值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>arr = [[1,2,3],[4,5,6],[7,8,9]]
<strong>输出:</strong>13
<strong>解释:</strong>
所有非零偏移下降路径包括:
[1,5,9], [1,5,7], [1,6,7], [1,6,8],
[2,4,8], [2,4,9], [2,6,7], [2,6,8],
[3,4,8], [3,4,9], [3,5,7], [3,5,9]
下降路径中数字和最小的是&nbsp;[1,5,7] ,所以答案是&nbsp;13 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length == arr[i].length &lt;= 200</code></li>
<li><code>-99 &lt;= arr[i][j] &lt;= 99</code></li>
</ul>
<p>给你一个单链表的引用结点&nbsp;<code>head</code>。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。</p>
<p>请你返回该链表所表示数字的 <strong>十进制值</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/12/15/graph-1.png" style="height: 108px; width: 426px;"></p>
<pre><strong>输入:</strong>head = [1,0,1]
<strong>输出:</strong>5
<strong>解释:</strong>二进制数 (101) 转化为十进制数 (5)
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>head = [0]
<strong>输出:</strong>0
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>head = [1]
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
<strong>输出:</strong>18880
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>head = [0,0]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>链表不为空。</li>
<li>链表的结点总数不超过&nbsp;<code>30</code></li>
<li>每个结点的值不是&nbsp;<code>0</code> 就是 <code>1</code></li>
</ul>
给你一个二叉树的根节点 <code>root</code> ,树中每个节点都存放有一个 <code>0</code><code>9</code> 之间的数字。
<div class="original__bRMd">
<div>
<p>每条从根节点到叶节点的路径都代表一个数字:</p>
<ul>
<li>例如,从根节点到叶节点的路径 <code>1 -> 2 -> 3</code> 表示数字 <code>123</code></li>
</ul>
<p>计算从根节点到叶节点生成的 <strong>所有数字之和</strong></p>
<p><strong>叶节点</strong> 是指没有子节点的节点。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg" style="width: 212px; height: 182px;" />
<pre>
<strong>输入:</strong>root = [1,2,3]
<strong>输出:</strong>25
<strong>解释:</strong>
从根到叶子节点路径 <code>1->2</code> 代表数字 <code>12</code>
从根到叶子节点路径 <code>1->3</code> 代表数字 <code>13</code>
因此,数字总和 = 12 + 13 = <code>25</code></pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg" style="width: 292px; height: 302px;" />
<pre>
<strong>输入:</strong>root = [4,9,0,5,1]
<strong>输出:</strong>1026
<strong>解释:</strong>
从根到叶子节点路径 <code>4->9->5</code> 代表数字 495
从根到叶子节点路径 <code>4->9->1</code> 代表数字 491
从根到叶子节点路径 <code>4->0</code> 代表数字 40
因此,数字总和 = 495 + 491 + 40 = <code>1026</code>
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点的数目在范围 <code>[1, 1000]</code></li>
<li><code>0 <= Node.val <= 9</code></li>
<li>树的深度不超过 <code>10</code></li>
</ul>
</div>
</div>
<p>我们定义「顺次数」为:每一位上的数字都比前一位上的数字大 <code>1</code> 的整数。</p>
<p>请你返回由&nbsp;<code>[low, high]</code>&nbsp;范围内所有顺次数组成的 <strong>有序</strong> 列表(从小到大排序)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输出:</strong>low = 100, high = 300
<strong>输出:</strong>[123,234]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输出:</strong>low = 1000, high = 13000
<strong>输出:</strong>[1234,2345,3456,4567,5678,6789,12345]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>10 &lt;= low &lt;= high &lt;= 10^9</code></li>
</ul>
<p>给你一个大小为 <code>m x n</code> 的矩阵 <code>mat</code> 和一个整数阈值 <code>threshold</code></p>
<p>请你返回元素总和小于或等于阈值的正方形区域的最大边长;如果没有这样的正方形区域,则返回 <strong></strong><br />
 </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/12/15/e1.png" style="height: 186px; width: 335px;" /></p>
<pre>
<strong>输入:</strong>mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4
<strong>输出:</strong>2
<strong>解释:</strong>总和小于或等于 4 的正方形的最大边长为 2,如图所示。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1
<strong>输出:</strong>0
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>mat = [[1,1,1,1],[1,0,0,0],[1,0,0,0],[1,0,0,0]], threshold = 6
<strong>输出:</strong>3
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>mat = [[18,70],[61,1],[25,85],[14,40],[11,96],[97,96],[63,45]], threshold = 40184
<strong>输出:</strong>2
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= m, n <= 300</code></li>
<li><code>m == mat.length</code></li>
<li><code>n == mat[i].length</code></li>
<li><code>0 <= mat[i][j] <= 10000</code></li>
<li><code>0 <= threshold <= 10^5</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code>,请你返回其中位数为&nbsp;<strong>偶数</strong>&nbsp;的数字的个数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [12,345,2,6,7896]
<strong>输出:</strong>2
<strong>解释:
</strong>12 是 2 位数字(位数为偶数)&nbsp;
345 是 3 位数字(位数为奇数)&nbsp;&nbsp;
2 是 1 位数字(位数为奇数)&nbsp;
6 是 1 位数字 位数为奇数)&nbsp;
7896 是 4 位数字(位数为偶数)&nbsp;&nbsp;
因此只有 12 和 7896 是位数为偶数的数字
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [555,901,482,1771]
<strong>输出:</strong>1
<strong>解释: </strong>
只有 1771 是位数为偶数的数字。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 500</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^5</code></li>
</ul>
<p>给你一个整数数组 <code>nums</code> 和一个正整数 <code>k</code>,请你判断是否可以把这个数组划分成一些由 <code>k</code> 个连续数字组成的集合。<br />
如果可以,请返回 <code>True</code>;否则,返回 <code>False</code></p>
<p> </p>
<p><strong>注意:</strong>此题目与 846 重复:<a href="https://leetcode-cn.com/problems/hand-of-straights/" target="_blank">https://leetcode-cn.com/problems/hand-of-straights/</a></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,3,3,4,4,5,6], k = 4
<strong>输出:</strong>true
<strong>解释:</strong>数组可以分成 [1,2,3,4] 和 [3,4,5,6]。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
<strong>输出:</strong>true
<strong>解释:</strong>数组可以分成 [1,2,3] , [2,3,4] , [3,4,5] 和 [9,10,11]。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>nums = [3,3,2,2,1,1], k = 3
<strong>输出:</strong>true
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,3,4], k = 3
<strong>输出:</strong>false
<strong>解释:</strong>数组不能分成几个大小为 3 的子数组。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= nums.length <= 10^5</code></li>
<li><code>1 <= nums[i] <= 10^9</code></li>
<li><code>1 <= k <= nums.length</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code> ,请你返回满足以下条件且出现次数最大的&nbsp;<strong>任意</strong>&nbsp;子串的出现次数:</p>
<ul>
<li>子串中不同字母的数目必须小于等于 <code>maxLetters</code></li>
<li>子串的长度必须大于等于&nbsp;<code>minSize</code> 且小于等于&nbsp;<code>maxSize</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;aababcaab&quot;, maxLetters = 2, minSize = 3, maxSize = 4
<strong>输出:</strong>2
<strong>解释:</strong>子串 &quot;aab&quot; 在原字符串中出现了 2 次。
它满足所有的要求:2 个不同的字母,长度为 3 (在 minSize 和 maxSize 范围内)。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaaa&quot;, maxLetters = 1, minSize = 3, maxSize = 3
<strong>输出:</strong>2
<strong>解释:</strong>子串 &quot;aaa&quot; 在原字符串中出现了 2 次,且它们有重叠部分。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;aabcabcab&quot;, maxLetters = 2, minSize = 2, maxSize = 3
<strong>输出:</strong>3
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;abcde&quot;, maxLetters = 2, minSize = 3, maxSize = 3
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>1 &lt;= maxLetters &lt;= 26</code></li>
<li><code>1 &lt;= minSize &lt;= maxSize &lt;= min(26, s.length)</code></li>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
</ul>
<p>给你&nbsp;<code>n</code>&nbsp;个盒子,每个盒子的格式为&nbsp;<code>[status, candies, keys, containedBoxes]</code>&nbsp;,其中:</p>
<ul>
<li>状态字&nbsp;<code>status[i]</code>:整数,如果&nbsp;<code>box[i]</code>&nbsp;是开的,那么是 <strong>1&nbsp;</strong>,否则是 <strong>0&nbsp;</strong></li>
<li>糖果数&nbsp;<code>candies[i]</code>: 整数,表示&nbsp;<code>box[i]</code> 中糖果的数目。</li>
<li>钥匙&nbsp;<code>keys[i]</code>:数组,表示你打开&nbsp;<code>box[i]</code>&nbsp;后,可以得到一些盒子的钥匙,每个元素分别为该钥匙对应盒子的下标。</li>
<li>内含的盒子&nbsp;<code>containedBoxes[i]</code>:整数,表示放在&nbsp;<code>box[i]</code>&nbsp;里的盒子所对应的下标。</li>
</ul>
<p>给你一个&nbsp;<code>initialBoxes</code> 数组,表示你现在得到的盒子,你可以获得里面的糖果,也可以用盒子里的钥匙打开新的盒子,还可以继续探索从这个盒子里找到的其他盒子。</p>
<p>请你按照上述规则,返回可以获得糖果的 <strong>最大数目&nbsp;</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>status = [1,0,1,0], candies = [7,5,4,100], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]
<strong>输出:</strong>16
<strong>解释:
</strong>一开始你有盒子 0 。你将获得它里面的 7 个糖果和盒子 1 和 2。
盒子 1 目前状态是关闭的,而且你还没有对应它的钥匙。所以你将会打开盒子 2 ,并得到里面的 4 个糖果和盒子 1 的钥匙。
在盒子 1 中,你会获得 5 个糖果和盒子 3 ,但是你没法获得盒子 3 的钥匙所以盒子 3 会保持关闭状态。
你总共可以获得的糖果数目 = 7 + 4 + 5 = 16 个。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>status = [1,0,0,0,0,0], candies = [1,1,1,1,1,1], keys = [[1,2,3,4,5],[],[],[],[],[]], containedBoxes = [[1,2,3,4,5],[],[],[],[],[]], initialBoxes = [0]
<strong>输出:</strong>6
<strong>解释:
</strong>你一开始拥有盒子 0 。打开它你可以找到盒子 1,2,3,4,5 和它们对应的钥匙。
打开这些盒子,你将获得所有盒子的糖果,所以总糖果数为 6 个。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>status = [1,1,1], candies = [100,1,100], keys = [[],[0,2],[]], containedBoxes = [[],[],[]], initialBoxes = [1]
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>status = [1], candies = [100], keys = [[]], containedBoxes = [[]], initialBoxes = []
<strong>输出:</strong>0
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>status = [1,1,1], candies = [2,3,2], keys = [[],[],[]], containedBoxes = [[],[],[]], initialBoxes = [2,1,0]
<strong>输出:</strong>7
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= status.length &lt;= 1000</code></li>
<li><code>status.length == candies.length == keys.length == containedBoxes.length == n</code></li>
<li><code>status[i]</code> 要么是&nbsp;<code>0</code>&nbsp;要么是&nbsp;<code>1</code></li>
<li><code>1 &lt;= candies[i] &lt;= 1000</code></li>
<li><code>0 &lt;= keys[i].length &lt;= status.length</code></li>
<li><code>0 &lt;= keys[i][j] &lt; status.length</code></li>
<li><code>keys[i]</code>&nbsp;中的值都是互不相同的。</li>
<li><code>0 &lt;= containedBoxes[i].length &lt;= status.length</code></li>
<li><code>0 &lt;= containedBoxes[i][j] &lt; status.length</code></li>
<li><code>containedBoxes[i]</code>&nbsp;中的值都是互不相同的。</li>
<li>每个盒子最多被一个盒子包含。</li>
<li><code>0 &lt;= initialBoxes.length&nbsp;&lt;= status.length</code></li>
<li><code>0 &lt;= initialBoxes[i] &lt; status.length</code></li>
</ul>
<p>给你一个数组 <code>arr</code> ,请你将每个元素用它右边最大的元素替换,如果是最后一个元素,用 <code>-1</code> 替换。</p>
<p>完成所有替换操作后,请你返回这个数组。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>arr = [17,18,5,4,6,1]
<strong>输出:</strong>[18,6,6,6,1,-1]
<strong>解释:</strong>
- 下标 0 的元素 --> 右侧最大元素是下标 1 的元素 (18)
- 下标 1 的元素 --> 右侧最大元素是下标 4 的元素 (6)
- 下标 2 的元素 --> 右侧最大元素是下标 4 的元素 (6)
- 下标 3 的元素 --> 右侧最大元素是下标 4 的元素 (6)
- 下标 4 的元素 --> 右侧最大元素是下标 5 的元素 (1)
- 下标 5 的元素 --> 右侧没有其他元素,替换为 -1
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>arr = [400]
<strong>输出:</strong>[-1]
<strong>解释:</strong>下标<strong> </strong>0 的元素右侧没有其他元素。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= arr.length <= 10<sup>4</sup></code></li>
<li><code>1 <= arr[i] <= 10<sup>5</sup></code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code> 和一个目标值&nbsp;<code>target</code> ,请你返回一个整数&nbsp;<code>value</code>&nbsp;,使得将数组中所有大于&nbsp;<code>value</code> 的值变成&nbsp;<code>value</code> 后,数组的和最接近&nbsp; <code>target</code>&nbsp;(最接近表示两者之差的绝对值最小)。</p>
<p>如果有多种使得和最接近&nbsp;<code>target</code>&nbsp;的方案,请你返回这些整数中的最小值。</p>
<p>请注意,答案不一定是&nbsp;<code>arr</code> 中的数字。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [4,9,3], target = 10
<strong>输出:</strong>3
<strong>解释:</strong>当选择 value 为 3 时,数组会变成 [3, 3, 3],和为 9 ,这是最接近 target 的方案。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [2,3,5], target = 10
<strong>输出:</strong>5
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [60864,25176,27249,21296,20204], target = 56803
<strong>输出:</strong>11361
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^4</code></li>
<li><code>1 &lt;= arr[i], target &lt;= 10^5</code></li>
</ul>
给你一个 <code>m x n</code> 的矩阵 <code>board</code> ,由若干字符 <code>'X'</code><code>'O'</code> ,找到所有被 <code>'X'</code> 围绕的区域,并将这些区域里所有的 <code>'O'</code><code>'X'</code> 填充。
<div class="original__bRMd">
<div>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/xogrid.jpg" style="width: 550px; height: 237px;" />
<pre>
<strong>输入:</strong>board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
<strong>输出:</strong>[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
<strong>解释:</strong>被围绕的区间不会存在于边界上,换句话说,任何边界上的 <code>'O'</code> 都不会被填充为 <code>'X'</code>。 任何不在边界上,或不与边界上的 <code>'O'</code> 相连的 <code>'O'</code> 最终都会被填充为 <code>'X'</code>。如果两个元素在水平或垂直方向相邻,则称它们是“相连”的。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>board = [["X"]]
<strong>输出:</strong>[["X"]]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == board.length</code></li>
<li><code>n == board[i].length</code></li>
<li><code>1 <= m, n <= 200</code></li>
<li><code>board[i][j]</code><code>'X'</code><code>'O'</code></li>
</ul>
</div>
</div>
<p>给你一个正方形字符数组&nbsp;<code>board</code>&nbsp;,你从数组最右下方的字符&nbsp;<code>&#39;S&#39;</code>&nbsp;出发。</p>
<p>你的目标是到达数组最左上角的字符&nbsp;<code>&#39;E&#39;</code> ,数组剩余的部分为数字字符&nbsp;<code>1, 2, ..., 9</code>&nbsp;或者障碍 <code>&#39;X&#39;</code>。在每一步移动中,你可以向上、向左或者左上方移动,可以移动的前提是到达的格子没有障碍。</p>
<p>一条路径的 「得分」 定义为:路径上所有数字的和。</p>
<p>请你返回一个列表,包含两个整数:第一个整数是 「得分」 的最大值,第二个整数是得到最大得分的方案数,请把结果对&nbsp;<strong><code>10^9 + 7</code></strong> <strong>取余</strong></p>
<p>如果没有任何路径可以到达终点,请返回&nbsp;<code>[0, 0]</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>board = [&quot;E23&quot;,&quot;2X2&quot;,&quot;12S&quot;]
<strong>输出:</strong>[7,1]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>board = [&quot;E12&quot;,&quot;1X1&quot;,&quot;21S&quot;]
<strong>输出:</strong>[4,2]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>board = [&quot;E11&quot;,&quot;XXX&quot;,&quot;11S&quot;]
<strong>输出:</strong>[0,0]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= board.length == board[i].length &lt;= 100</code></li>
</ul>
<p>给你一棵二叉树的根节点 <code>root</code> ,请你返回 <strong>层数最深的叶子节点的和</strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/12/28/1483_ex1.png" style="height: 265px; width: 273px;" /></strong></p>
<pre>
<strong>输入:</strong>root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
<strong>输出:</strong>15
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
<strong>输出:</strong>19
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点数目在范围 <code>[1, 10<sup>4</sup>]</code> 之间。</li>
<li><code>1 <= Node.val <= 100</code></li>
</ul>
<p>给你一个整数&nbsp;<code>n</code>,请你返回 <strong>任意&nbsp;</strong>一个由 <code>n</code>&nbsp;<strong>各不相同&nbsp;</strong>的整数组成的数组,并且这 <code>n</code> 个数相加和为 <code>0</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 5
<strong>输出:</strong>[-7,-1,1,3,4]
<strong>解释:</strong>这些数组也是正确的 [-5,-1,1,2,3],[-3,-1,2,-2,4]。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 3
<strong>输出:</strong>[-1,0,1]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 1
<strong>输出:</strong>[0]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 1000</code></li>
</ul>
<p>给你&nbsp;<code>root1</code><code>root2</code>&nbsp;这两棵二叉搜索树。</p>
<p>请你返回一个列表,其中包含&nbsp;<strong>两棵树&nbsp;</strong>中的所有整数并按 <strong>升序</strong> 排序。.</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/12/29/q2-e1.png"></p>
<pre><strong>输入:</strong>root1 = [2,1,4], root2 = [1,0,3]
<strong>输出:</strong>[0,1,1,2,3,4]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>root1 = [0,-10,10], root2 = [5,1,7,0,2]
<strong>输出:</strong>[-10,0,0,1,2,5,7,10]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>root1 = [], root2 = [5,1,7,0,2]
<strong>输出:</strong>[0,1,2,5,7]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>root1 = [0,-10,10], root2 = []
<strong>输出:</strong>[-10,0,10]
</pre>
<p><strong>示例 5:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/12/29/q2-e5-.png"></p>
<pre><strong>输入:</strong>root1 = [1,null,8], root2 = [8,1]
<strong>输出:</strong>[1,1,8,8]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>每棵树最多有&nbsp;<code>5000</code>&nbsp;个节点。</li>
<li>每个节点的值在&nbsp;<code>[-10^5, 10^5]</code>&nbsp;之间。</li>
</ul>
<p>这里有一个非负整数数组&nbsp;<code>arr</code>,你最开始位于该数组的起始下标&nbsp;<code>start</code>&nbsp;处。当你位于下标&nbsp;<code>i</code>&nbsp;处时,你可以跳到&nbsp;<code>i + arr[i]</code> 或者 <code>i - arr[i]</code></p>
<p>请你判断自己是否能够跳到对应元素值为 0 的 <strong>任一</strong> 下标处。</p>
<p>注意,不管是什么情况下,你都无法跳到数组之外。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [4,2,3,0,3,1,2], start = 5
<strong>输出:</strong>true
<strong>解释:</strong>
到达值为 0 的下标 3 有以下可能方案:
下标 5 -&gt; 下标 4 -&gt; 下标 1 -&gt; 下标 3
下标 5 -&gt; 下标 6 -&gt; 下标 4 -&gt; 下标 1 -&gt; 下标 3
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [4,2,3,0,3,1,2], start = 0
<strong>输出:</strong>true
<strong>解释:
</strong>到达值为 0 的下标 3 有以下可能方案:
下标 0 -&gt; 下标 4 -&gt; 下标 1 -&gt; 下标 3
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [3,0,2,1,2], start = 2
<strong>输出:</strong>false
<strong>解释:</strong>无法到达值为 0 的下标 1 处。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 5 * 10^4</code></li>
<li><code>0 &lt;= arr[i] &lt;&nbsp;arr.length</code></li>
<li><code>0 &lt;= start &lt; arr.length</code></li>
</ul>
<p>给你一个方程,左边用&nbsp;<code>words</code>&nbsp;表示,右边用&nbsp;<code>result</code> 表示。</p>
<p>你需要根据以下规则检查方程是否可解:</p>
<ul>
<li>每个字符都会被解码成一位数字(0 - 9)。</li>
<li>每对不同的字符必须映射到不同的数字。</li>
<li>每个 <code>words[i]</code><code>result</code>&nbsp;都会被解码成一个没有前导零的数字。</li>
<li>左侧数字之和(<code>words</code>)等于右侧数字(<code>result</code>)。&nbsp;</li>
</ul>
<p>如果方程可解,返回&nbsp;<code>True</code>,否则返回&nbsp;<code>False</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>words = [&quot;SEND&quot;,&quot;MORE&quot;], result = &quot;MONEY&quot;
<strong>输出:</strong>true
<strong>解释:</strong>映射 &#39;S&#39;-&gt; 9, &#39;E&#39;-&gt;5, &#39;N&#39;-&gt;6, &#39;D&#39;-&gt;7, &#39;M&#39;-&gt;1, &#39;O&#39;-&gt;0, &#39;R&#39;-&gt;8, &#39;Y&#39;-&gt;&#39;2&#39;
所以 &quot;SEND&quot; + &quot;MORE&quot; = &quot;MONEY&quot; , 9567 + 1085 = 10652</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>words = [&quot;SIX&quot;,&quot;SEVEN&quot;,&quot;SEVEN&quot;], result = &quot;TWENTY&quot;
<strong>输出:</strong>true
<strong>解释:</strong>映射 &#39;S&#39;-&gt; 6, &#39;I&#39;-&gt;5, &#39;X&#39;-&gt;0, &#39;E&#39;-&gt;8, &#39;V&#39;-&gt;7, &#39;N&#39;-&gt;2, &#39;T&#39;-&gt;1, &#39;W&#39;-&gt;&#39;3&#39;, &#39;Y&#39;-&gt;4
所以 &quot;SIX&quot; + &quot;SEVEN&quot; + &quot;SEVEN&quot; = &quot;TWENTY&quot; , 650 + 68782 + 68782 = 138214</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>words = [&quot;THIS&quot;,&quot;IS&quot;,&quot;TOO&quot;], result = &quot;FUNNY&quot;
<strong>输出:</strong>true
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>words = [&quot;LEET&quot;,&quot;CODE&quot;], result = &quot;POINT&quot;
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= words.length &lt;= 5</code></li>
<li><code>1 &lt;= words[i].length,&nbsp;results.length&nbsp;&lt;= 7</code></li>
<li><code>words[i], result</code>&nbsp;只含有大写英文字母</li>
<li>表达式中使用的不同字符数最大为&nbsp;10</li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>,它由数字(<code>&#39;0&#39;</code> - <code>&#39;9&#39;</code>)和&nbsp;<code>&#39;#&#39;</code>&nbsp;组成。我们希望按下述规则将&nbsp;<code>s</code>&nbsp;映射为一些小写英文字符:</p>
<ul>
<li>字符(<code>&#39;a&#39;</code> - <code>&#39;i&#39;</code>)分别用(<code>&#39;1&#39;</code> -&nbsp;<code>&#39;9&#39;</code>)表示。</li>
<li>字符(<code>&#39;j&#39;</code> - <code>&#39;z&#39;</code>)分别用(<code>&#39;10#&#39;</code>&nbsp;-&nbsp;<code>&#39;26#&#39;</code>)表示。&nbsp;</li>
</ul>
<p>返回映射之后形成的新字符串。</p>
<p>题目数据保证映射始终唯一。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;10#11#12&quot;
<strong>输出:</strong>&quot;jkab&quot;
<strong>解释:</strong>&quot;j&quot; -&gt; &quot;10#&quot; , &quot;k&quot; -&gt; &quot;11#&quot; , &quot;a&quot; -&gt; &quot;1&quot; , &quot;b&quot; -&gt; &quot;2&quot;.
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;1326#&quot;
<strong>输出:</strong>&quot;acz&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;25#&quot;
<strong>输出:</strong>&quot;y&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;12345678910#11#12#13#14#15#16#17#18#19#20#21#22#23#24#25#26#&quot;
<strong>输出:</strong>&quot;abcdefghijklmnopqrstuvwxyz&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 1000</code></li>
<li><code>s[i]</code> 只包含数字(<code>&#39;0&#39;</code>-<code>&#39;9&#39;</code>)和&nbsp;<code>&#39;#&#39;</code>&nbsp;字符。</li>
<li><code>s</code>&nbsp;是映射始终存在的有效字符串。</li>
</ul>
<p>有一个正整数数组 <code>arr</code>,现给你一个对应的查询数组 <code>queries</code>,其中 <code>queries[i] = [L<sub>i, </sub>R<sub>i</sub>]</code></p>
<p>对于每个查询 <code>i</code>,请你计算从 <code>L<sub>i</sub></code> 到 <code>R<sub>i</sub></code> 的 <strong>XOR</strong> 值(即 <code>arr[L<sub>i</sub>] <strong>xor</strong> arr[L<sub>i</sub>+1] <strong>xor</strong> ... <strong>xor</strong> arr[R<sub>i</sub>]</code>)作为本次查询的结果。</p>
<p>并返回一个包含给定查询 <code>queries</code> 所有结果的数组。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]
<strong>输出:</strong>[2,7,14,8]
<strong>解释:</strong>
数组中元素的二进制表示形式是:
1 = 0001
3 = 0011
4 = 0100
8 = 1000
查询的 XOR 值为:
[0,1] = 1 xor 3 = 2
[1,2] = 3 xor 4 = 7
[0,3] = 1 xor 3 xor 4 xor 8 = 14
[3,3] = 8
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]
<strong>输出:</strong>[8,0,4,4]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= arr.length <= 3 * 10^4</code></li>
<li><code>1 <= arr[i] <= 10^9</code></li>
<li><code>1 <= queries.length <= 3 * 10^4</code></li>
<li><code>queries[i].length == 2</code></li>
<li><code>0 <= queries[i][0] <= queries[i][1] < arr.length</code></li>
</ul>
<p>给你一个字符串 <code>s</code>,请你将<em> </em><code>s</code><em> </em>分割成一些子串,使每个子串都是 <strong>回文串</strong> 。返回 <code>s</code> 所有可能的分割方案。</p>
<p><strong>回文串</strong> 是正着读和反着读都一样的字符串。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "aab"
<strong>输出:</strong>[["a","a","b"],["aa","b"]]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "a"
<strong>输出:</strong>[["a"]]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 16</code></li>
<li><code>s</code> 仅由小写英文字母组成</li>
</ul>
<p>&nbsp;<code>n</code> 个人,每个人都有一个&nbsp; <code>0</code>&nbsp;&nbsp;<code>n-1</code>&nbsp;的唯一&nbsp;<em>id</em>&nbsp;</p>
<p>给你数组 <code>watchedVideos</code>&nbsp;&nbsp;<code>friends</code>&nbsp;,其中&nbsp;<code>watchedVideos[i]</code>&nbsp;&nbsp;<code>friends[i]</code>&nbsp;分别表示&nbsp;<code>id = i</code>&nbsp;的人观看过的视频列表和他的好友列表。</p>
<p>Level&nbsp;<strong>1</strong>&nbsp;的视频包含所有你好友观看过的视频,level&nbsp;<strong>2</strong>&nbsp;的视频包含所有你好友的好友观看过的视频,以此类推。一般的,Level 为 <strong>k</strong>&nbsp;的视频包含所有从你出发,最短距离为&nbsp;<strong>k</strong>&nbsp;的好友观看过的视频。</p>
<p>给定你的&nbsp;<code>id</code>&nbsp; 和一个&nbsp;<code>level</code>&nbsp;值,请你找出所有指定 <code>level</code> 的视频,并将它们按观看频率升序返回。如果有频率相同的视频,请将它们按字母顺序从小到大排列。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/03/leetcode_friends_1.png" style="height: 179px; width: 129px;"></strong></p>
<pre><strong>输入:</strong>watchedVideos = [[&quot;A&quot;,&quot;B&quot;],[&quot;C&quot;],[&quot;B&quot;,&quot;C&quot;],[&quot;D&quot;]], friends = [[1,2],[0,3],[0,3],[1,2]], id = 0, level = 1
<strong>输出:</strong>[&quot;B&quot;,&quot;C&quot;]
<strong>解释:</strong>
你的 id 为 0(绿色),你的朋友包括(黄色):
id 为 1 -&gt; watchedVideos = [&quot;C&quot;]&nbsp;
id 为 2 -&gt; watchedVideos = [&quot;B&quot;,&quot;C&quot;]&nbsp;
你朋友观看过视频的频率为:
B -&gt; 1&nbsp;
C -&gt; 2
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/03/leetcode_friends_2.png" style="height: 179px; width: 129px;"></strong></p>
<pre><strong>输入:</strong>watchedVideos = [[&quot;A&quot;,&quot;B&quot;],[&quot;C&quot;],[&quot;B&quot;,&quot;C&quot;],[&quot;D&quot;]], friends = [[1,2],[0,3],[0,3],[1,2]], id = 0, level = 2
<strong>输出:</strong>[&quot;D&quot;]
<strong>解释:</strong>
你的 id 为 0(绿色),你朋友的朋友只有一个人,他的 id 为 3(黄色)。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == watchedVideos.length ==&nbsp;friends.length</code></li>
<li><code>2 &lt;= n&nbsp;&lt;= 100</code></li>
<li><code>1 &lt;=&nbsp;watchedVideos[i].length &lt;= 100</code></li>
<li><code>1 &lt;=&nbsp;watchedVideos[i][j].length &lt;= 8</code></li>
<li><code>0 &lt;= friends[i].length &lt; n</code></li>
<li><code>0 &lt;= friends[i][j]&nbsp;&lt; n</code></li>
<li><code>0 &lt;= id &lt; n</code></li>
<li><code>1 &lt;= level &lt; n</code></li>
<li>如果&nbsp;<code>friends[i]</code> 包含&nbsp;<code>j</code>&nbsp;,那么&nbsp;<code>friends[j]</code> 包含&nbsp;<code>i</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>&nbsp;,每一次操作你都可以在字符串的任意位置插入任意字符。</p>
<p>请你返回让&nbsp;<code>s</code>&nbsp;成为回文串的&nbsp;<strong>最少操作次数</strong>&nbsp;</p>
<p>「回文串」是正读和反读都相同的字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;zzazz&quot;
<strong>输出:</strong>0
<strong>解释:</strong>字符串 &quot;zzazz&quot; 已经是回文串了,所以不需要做任何插入操作。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;mbadm&quot;
<strong>输出:</strong>2
<strong>解释:</strong>字符串可变为 &quot;mbdadbm&quot; 或者 &quot;mdbabdm&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;leetcode&quot;
<strong>输出:</strong>5
<strong>解释:</strong>插入 5 个字符后字符串变为 &quot;leetcodocteel&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;g&quot;
<strong>输出:</strong>0
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;no&quot;
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 500</code></li>
<li><code>s</code>&nbsp;中所有字符都是小写字母。</li>
</ul>
<p>给你一个以行程长度编码压缩的整数列表 <code>nums</code> 。</p>
<p>考虑每对相邻的两个元素 <code>[freq, val] = [nums[2*i], nums[2*i+1]]</code> (其中 <code>i >= 0</code> ),每一对都表示解压后子列表中有 <code>freq</code> 个值为 <code>val</code> 的元素,你需要从左到右连接所有子列表以生成解压后的列表。</p>
<p>请你返回解压后的列表。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,3,4]
<strong>输出:</strong>[2,4,4,4]
<strong>解释:</strong>第一对 [1,2] 代表着 2 的出现频次为 1,所以生成数组 [2]。
第二对 [3,4] 代表着 4 的出现频次为 3,所以生成数组 [4,4,4]。
最后将它们串联到一起 [2] + [4,4,4] = [2,4,4,4]。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,1,2,3]
<strong>输出:</strong>[1,3,3]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 <= nums.length <= 100</code></li>
<li><code>nums.length % 2 == 0</code></li>
<li><code>1 <= nums[i] <= 100</code></li>
</ul>
<p>给你一个 <code>m x n</code> 的矩阵 <code>mat</code> 和一个整数 <code>k</code> ,请你返回一个矩阵 <code>answer</code> ,其中每个 <code>answer[i][j]</code> 是所有满足下述条件的元素 <code>mat[r][c]</code> 的和: </p>
<ul>
<li><code>i - k <= r <= i + k, </code></li>
<li><code>j - k <= c <= j + k</code></li>
<li><code>(r, c)</code> 在矩阵内。</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>mat = [[1,2,3],[4,5,6],[7,8,9]], k = 1
<strong>输出:</strong>[[12,21,16],[27,45,33],[24,39,28]]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>mat = [[1,2,3],[4,5,6],[7,8,9]], k = 2
<strong>输出:</strong>[[45,45,45],[45,45,45],[45,45,45]]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == mat.length</code></li>
<li><code>n == mat[i].length</code></li>
<li><code>1 <= m, n, k <= 100</code></li>
<li><code>1 <= mat[i][j] <= 100</code></li>
</ul>
<p>给你一棵二叉树,请你返回满足以下条件的所有节点的值之和:</p>
<ul>
<li>该节点的祖父节点的值为偶数。(一个节点的祖父节点是指该节点的父节点的父节点。)</li>
</ul>
<p>如果不存在祖父节点值为偶数的节点,那么返回&nbsp;<code>0</code></p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/10/1473_ex1.png" style="height: 214px; width: 350px;"></strong></p>
<pre><strong>输入:</strong>root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
<strong>输出:</strong>18
<strong>解释:</strong>图中红色节点的祖父节点的值为偶数,蓝色节点为这些红色节点的祖父节点。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点的数目在&nbsp;<code>1</code>&nbsp;<code>10^4</code>&nbsp;之间。</li>
<li>每个节点的值在&nbsp;<code>1</code>&nbsp;<code>100</code> 之间。</li>
</ul>
<p>给你一个字符串&nbsp;<code>text</code> ,请你返回满足下述条件的&nbsp;<strong>不同</strong> 非空子字符串的数目:</p>
<ul>
<li>可以写成某个字符串与其自身相连接的形式(即,可以写为 <code>a&nbsp;+ a</code>,其中 <code>a</code> 是某个字符串)。</li>
</ul>
<p>例如,<code>abcabc</code>&nbsp;就是&nbsp;<code>abc</code>&nbsp;和它自身连接形成的。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>text = &quot;abcabcabc&quot;
<strong>输出:</strong>3
<strong>解释:</strong>3 个子字符串分别为 &quot;abcabc&quot;&quot;bcabca&quot;&quot;cabcab&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>text = &quot;leetcodeleetcode&quot;
<strong>输出:</strong>2
<strong>解释:</strong>2 个子字符串为 &quot;ee&quot;&quot;leetcodeleetcode&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= text.length &lt;= 2000</code></li>
<li><code>text</code>&nbsp;只包含小写英文字母。</li>
</ul>
<p>「无零整数」是十进制表示中 <strong>不含任何 0</strong>&nbsp;的正整数。</p>
<p>给你一个整数&nbsp;<code>n</code>,请你返回一个 <strong>由两个整数组成的列表</strong> <code>[A, B]</code>,满足:</p>
<ul>
<li><code>A</code><code>B</code>&nbsp;都是无零整数</li>
<li><code>A + B = n</code></li>
</ul>
<p>题目数据保证至少有一个有效的解决方案。</p>
<p>如果存在多个有效解决方案,你可以返回其中任意一个。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>[1,1]
<strong>解释:</strong>A = 1, B = 1. A + B = n 并且 A 和 B 的十进制表示形式都不包含任何 0 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 11
<strong>输出:</strong>[2,9]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 10000
<strong>输出:</strong>[1,9999]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 69
<strong>输出:</strong>[1,68]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 1010
<strong>输出:</strong>[11,999]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 10^4</code></li>
</ul>
<p>给你三个正整数&nbsp;<code>a</code><code>b</code><code>c</code></p>
<p>你可以对 <code>a</code><code>b</code>&nbsp;的二进制表示进行位翻转操作,返回能够使按位或运算&nbsp; &nbsp;<code>a</code> OR <code>b</code> == <code>c</code>&nbsp;&nbsp;成立的最小翻转次数。</p>
<p>「位翻转操作」是指将一个数的二进制表示任何单个位上的 1 变成 0 或者 0 变成 1 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/11/sample_3_1676.png" style="height: 87px; width: 260px;"></p>
<pre><strong>输入:</strong>a = 2, b = 6, c = 5
<strong>输出:</strong>3
<strong>解释:</strong>翻转后 a = 1 , b = 4 , c = 5 使得 <code>a</code> OR <code>b</code> == <code>c</code></pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>a = 4, b = 2, c = 7
<strong>输出:</strong>1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>a = 1, b = 2, c = 3
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= a &lt;= 10^9</code></li>
<li><code>1 &lt;= b&nbsp;&lt;= 10^9</code></li>
<li><code>1 &lt;= c&nbsp;&lt;= 10^9</code></li>
</ul>
<p>用以太网线缆将&nbsp;<code>n</code>&nbsp;台计算机连接成一个网络,计算机的编号从&nbsp;<code>0</code>&nbsp;&nbsp;<code>n-1</code>。线缆用&nbsp;<code>connections</code>&nbsp;表示,其中&nbsp;<code>connections[i] = [a, b]</code>&nbsp;连接了计算机&nbsp;<code>a</code>&nbsp;&nbsp;<code>b</code></p>
<p>网络中的任何一台计算机都可以通过网络直接或者间接访问同一个网络中其他任意一台计算机。</p>
<p>给你这个计算机网络的初始布线&nbsp;<code>connections</code>,你可以拔开任意两台直连计算机之间的线缆,并用它连接一对未直连的计算机。请你计算并返回使所有计算机都连通所需的最少操作次数。如果不可能,则返回&nbsp;-1 。&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/11/sample_1_1677.png" style="height: 167px; width: 570px;"></strong></p>
<pre><strong>输入:</strong>n = 4, connections = [[0,1],[0,2],[1,2]]
<strong>输出:</strong>1
<strong>解释:</strong>拔下计算机 1 和 2 之间的线缆,并将它插到计算机 1 和 3 上。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/11/sample_2_1677.png" style="height: 175px; width: 660px;"></strong></p>
<pre><strong>输入:</strong>n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
<strong>输出:</strong>2
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
<strong>输出:</strong>-1
<strong>解释:</strong>线缆数量不足。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 5, connections = [[0,1],[0,2],[3,4],[2,3]]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li><code>1 &lt;= connections.length &lt;= min(n*(n-1)/2, 10^5)</code></li>
<li><code>connections[i].length == 2</code></li>
<li><code>0 &lt;= connections[i][0], connections[i][1]&nbsp;&lt; n</code></li>
<li><code>connections[i][0] != connections[i][1]</code></li>
<li>没有重复的连接。</li>
<li>两台计算机不会通过多条线缆连接。</li>
</ul>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/11/leetcode_keyboard.png" style="height: 250px; width: 417px;"></p>
<p>二指输入法定制键盘在 XY 平面上的布局如上图所示,其中每个大写英文字母都位于某个坐标处,例如字母&nbsp;<strong>A</strong>&nbsp;位于坐标&nbsp;<strong>(0,0)</strong>,字母&nbsp;<strong>B</strong>&nbsp;位于坐标&nbsp;<strong>(0,1)</strong>,字母&nbsp;<strong>P</strong>&nbsp;位于坐标&nbsp;<strong>(2,3)</strong>&nbsp;且字母 <strong>Z</strong>&nbsp;位于坐标&nbsp;<strong>(4,1)</strong></p>
<p>给你一个待输入字符串&nbsp;<code>word</code>,请你计算并返回在仅使用两根手指的情况下,键入该字符串需要的最小移动总距离。坐标&nbsp;<strong>(x<sub>1</sub>,y<sub>1</sub>)</strong><strong>(x<sub>2</sub>,y<sub>2</sub>)</strong> 之间的距离是&nbsp;<strong>|x<sub>1</sub> - x<sub>2</sub>| + |y<sub>1</sub> - y<sub>2</sub>|</strong>&nbsp;</p>
<p>注意,两根手指的起始位置是零代价的,不计入移动总距离。你的两根手指的起始位置也不必从首字母或者前两个字母开始。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>word = &quot;CAKE&quot;
<strong>输出:</strong>3
<strong>解释:
</strong>使用两根手指输入 &quot;CAKE&quot; 的最佳方案之一是:
手指 1 在字母 &#39;C&#39; 上 -&gt; 移动距离 = 0
手指 1 在字母 &#39;A&#39; 上 -&gt; 移动距离 = 从字母 &#39;C&#39; 到字母 &#39;A&#39; 的距离 = 2
手指 2 在字母 &#39;K&#39; 上 -&gt; 移动距离 = 0
手指 2 在字母 &#39;E&#39; 上 -&gt; 移动距离 = 从字母 &#39;K&#39; 到字母 &#39;E&#39; 的距离 = 1
总距离 = 3
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>word = &quot;HAPPY&quot;
<strong>输出:</strong>6
<strong>解释: </strong>
使用两根手指输入 &quot;HAPPY&quot; 的最佳方案之一是:
手指 1 在字母 &#39;H&#39; 上 -&gt; 移动距离 = 0
手指 1 在字母 &#39;A&#39; 上 -&gt; 移动距离 = 从字母 &#39;H&#39; 到字母 &#39;A&#39; 的距离 = 2
手指 2 在字母 &#39;P&#39; 上 -&gt; 移动距离 = 0
手指 2 在字母 &#39;P&#39; 上 -&gt; 移动距离 = 从字母 &#39;P&#39; 到字母 &#39;P&#39; 的距离 = 0
手指 1 在字母 &#39;Y&#39; 上 -&gt; 移动距离 = 从字母 &#39;A&#39; 到字母 &#39;Y&#39; 的距离 = 4
总距离 = 6
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>word = &quot;NEW&quot;
<strong>输出:</strong>3
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>word = &quot;YEAR&quot;
<strong>输出:</strong>7
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= word.length &lt;= 300</code></li>
<li>每个 <code>word[i]</code>&nbsp;都是一个大写英文字母。</li>
</ul>
<p>给你一个字符串 <code>s</code>,请你将 <code>s</code> 分割成一些子串,使每个子串都是回文。</p>
<p>返回符合要求的 <strong>最少分割次数</strong></p>
<div class="original__bRMd">
<div>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "aab"
<strong>输出:</strong>1
<strong>解释:</strong>只需一次分割就可将 <em>s </em>分割成 ["aa","b"] 这样两个回文子串。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "a"
<strong>输出:</strong>0
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "ab"
<strong>输出:</strong>1
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 2000</code></li>
<li><code>s</code> 仅由小写英文字母组成</li>
</ul>
</div>
</div>
<p>给你一个仅由数字 6 和 9 组成的正整数&nbsp;<code>num</code></p>
<p>你最多只能翻转一位数字,将 6 变成&nbsp;9,或者把&nbsp;9 变成&nbsp;6 。</p>
<p>请返回你可以得到的最大数字。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>num = 9669
<strong>输出:</strong>9969
<strong>解释:</strong>
改变第一位数字可以得到 6669 。
改变第二位数字可以得到 9969 。
改变第三位数字可以得到 9699 。
改变第四位数字可以得到 9666 。
其中最大的数字是 9969 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>num = 9996
<strong>输出:</strong>9999
<strong>解释:</strong>将最后一位从 6 变到 9,其结果 9999 是最大的数。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>num = 9999
<strong>输出:</strong>9999
<strong>解释:</strong>无需改变就已经是最大的数字了。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= num &lt;= 10^4</code></li>
<li><code>num</code>&nbsp;每一位上的数字都是 6 或者&nbsp;9 。</li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>。请你按照单词在 <code>s</code> 中的出现顺序将它们全部竖直返回。<br>
单词应该以字符串列表的形式返回,必要时用空格补位,但输出尾部的空格需要删除(不允许尾随空格)。<br>
每个单词只能放在一列上,每一列中也只能有一个单词。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;HOW ARE YOU&quot;
<strong>输出:</strong>[&quot;HAY&quot;,&quot;ORO&quot;,&quot;WEU&quot;]
<strong>解释:</strong>每个单词都应该竖直打印。
&quot;HAY&quot;
&nbsp;&quot;ORO&quot;
&nbsp;&quot;WEU&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;TO BE OR NOT TO BE&quot;
<strong>输出:</strong>[&quot;TBONTB&quot;,&quot;OEROOE&quot;,&quot; T&quot;]
<strong>解释:</strong>题目允许使用空格补位,但不允许输出末尾出现空格。
&quot;TBONTB&quot;
&quot;OEROOE&quot;
&quot; T&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;CONTEST IS COMING&quot;
<strong>输出:</strong>[&quot;CIC&quot;,&quot;OSO&quot;,&quot;N M&quot;,&quot;T I&quot;,&quot;E N&quot;,&quot;S G&quot;,&quot;T&quot;]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 200</code></li>
<li><code>s</code>&nbsp;仅含大写英文字母。</li>
<li>题目数据保证两个单词之间只有一个空格。</li>
</ul>
<p>给你一棵以&nbsp;<code>root</code>&nbsp;为根的二叉树和一个整数&nbsp;<code>target</code>&nbsp;,请你删除所有值为&nbsp;<code>target</code>&nbsp;<strong>叶子节点</strong></p>
<p>注意,一旦删除值为&nbsp;<code>target</code>&nbsp;的叶子节点,它的父节点就可能变成叶子节点;如果新叶子节点的值恰好也是&nbsp;<code>target</code> ,那么这个节点也应该被删除。</p>
<p>也就是说,你需要重复此过程直到不能继续删除。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/16/sample_1_1684.png" style="height: 120px; width: 550px;"></strong></p>
<pre><strong>输入:</strong>root = [1,2,3,2,null,2,4], target = 2
<strong>输出:</strong>[1,null,3,null,4]
<strong>解释:
</strong>上面左边的图中,绿色节点为叶子节点,且它们的值与 target 相同(同为 2 ),它们会被删除,得到中间的图。
有一个新的节点变成了叶子节点且它的值与 target 相同,所以将再次进行删除,从而得到最右边的图。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/16/sample_2_1684.png" style="height: 120px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>root = [1,3,3,3,2], target = 3
<strong>输出:</strong>[1,3,null,null,2]
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/16/sample_3_1684.png" style="width: 450px;"></strong></p>
<pre><strong>输入:</strong>root = [1,2,null,2,null,2], target = 2
<strong>输出:</strong>[1]
<strong>解释:</strong>每一步都删除一个绿色的叶子节点(值为 2)。</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>root = [1,1,1], target = 1
<strong>输出:</strong>[]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>root = [1,2,3], target = 1
<strong>输出:</strong>[1,2,3]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= target&nbsp;&lt;= 1000</code></li>
<li>每一棵树最多有 <code>3000</code> 个节点。</li>
<li>每一个节点值的范围是&nbsp;<code>[1, 1000]</code>&nbsp;</li>
</ul>
<p>在 x 轴上有一个一维的花园。花园长度为&nbsp;<code>n</code>,从点&nbsp;<code>0</code>&nbsp;开始,到点&nbsp;<code>n</code>&nbsp;结束。</p>
<p>花园里总共有&nbsp;<code>n + 1</code> 个水龙头,分别位于&nbsp;<code>[0, 1, ..., n]</code></p>
<p>给你一个整数&nbsp;<code>n</code>&nbsp;和一个长度为&nbsp;<code>n + 1</code> 的整数数组&nbsp;<code>ranges</code>&nbsp;,其中&nbsp;<code>ranges[i]</code> (下标从 0 开始)表示:如果打开点&nbsp;<code>i</code>&nbsp;处的水龙头,可以灌溉的区域为&nbsp;<code>[i -&nbsp; ranges[i], i + ranges[i]]</code>&nbsp;</p>
<p>请你返回可以灌溉整个花园的&nbsp;<strong>最少水龙头数目</strong>&nbsp;。如果花园始终存在无法灌溉到的地方,请你返回&nbsp;<strong>-1</strong>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/19/1685_example_1.png" style="width: 530px;"></p>
<pre><strong>输入:</strong>n = 5, ranges = [3,4,1,1,0,0]
<strong>输出:</strong>1
<strong>解释:
</strong>点 0 处的水龙头可以灌溉区间 [-3,3]
点 1 处的水龙头可以灌溉区间 [-3,5]
点 2 处的水龙头可以灌溉区间 [1,3]
点 3 处的水龙头可以灌溉区间 [2,4]
点 4 处的水龙头可以灌溉区间 [4,4]
点 5 处的水龙头可以灌溉区间 [5,5]
只需要打开点 1 处的水龙头即可灌溉整个花园 [0,5] 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 3, ranges = [0,0,0,0]
<strong>输出:</strong>-1
<strong>解释:</strong>即使打开所有水龙头,你也无法灌溉整个花园。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 7, ranges = [1,2,1,0,2,1,0,1]
<strong>输出:</strong>3
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 8, ranges = [4,0,0,0,0,0,0,0,4]
<strong>输出:</strong>2
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 8, ranges = [4,0,0,0,4,0,0,0,4]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^4</code></li>
<li><code>ranges.length == n + 1</code></li>
<li><code>0 &lt;= ranges[i] &lt;= 100</code></li>
</ul>
<p>给你一个由小写英文字母组成的回文字符串 <code>palindrome</code> ,请你将其中 <strong>一个</strong> 字符用任意小写英文字母替换,使得结果字符串的 <strong>字典序最小</strong> ,且 <strong>不是</strong> 回文串。</p>
<p>请你返回结果字符串。如果无法做到,则返回一个 <strong>空串</strong></p>
<p>如果两个字符串长度相同,那么字符串 <code>a</code> 字典序比字符串 <code>b</code> 小可以这样定义:在 <code>a</code><code>b</code> 出现不同的第一个位置上,字符串 <code>a</code> 中的字符严格小于 <code>b</code> 中的对应字符。例如,<code>"abcc”</code> 字典序比 <code>"abcd"</code> 小,因为不同的第一个位置是在第四个字符,显然 <code>'c'</code><code>'d'</code> 小。</p>
 
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>palindrome = "abccba"
<strong>输出:</strong>"aaccba"
<strong>解释:</strong>存在多种方法可以使 "abccba" 不是回文,例如 "<em><strong>z</strong></em>bccba", "a<em><strong>a</strong></em>ccba", 和 "ab<em><strong>a</strong></em>cba" 。
在所有方法中,"aaccba" 的字典序最小。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>palindrome = "a"
<strong>输出:</strong>""
<strong>解释:</strong>不存在替换一个字符使 "a" 变成非回文的方法,所以返回空字符串。</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>palindrome = "aa"
<strong>输出:</strong>"ab"</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>palindrome = "aba"
<strong>输出:</strong>"abb"
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= palindrome.length <= 1000</code></li>
<li><code>palindrome</code> 只包含小写英文字母。</li>
</ul>
<p><strong>矩阵对角线</strong> 是一条从矩阵最上面行或者最左侧列中的某个元素开始的对角线,沿右下方向一直到矩阵末尾的元素。例如,矩阵 <code>mat</code><code>6</code><code>3</code> 列,从 <code>mat[2][0]</code> 开始的 <strong>矩阵对角线</strong> 将会经过 <code>mat[2][0]</code><code>mat[3][1]</code><code>mat[4][2]</code></p>
<p>给你一个 <code>m * n</code> 的整数矩阵 <code>mat</code> ,请你将同一条 <strong>矩阵对角线 </strong>上的元素按升序排序后,返回排好序的矩阵。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/25/1482_example_1_2.png" style="height: 198px; width: 500px;" /></p>
<pre>
<strong>输入:</strong>mat = [[3,3,1,1],[2,2,1,2],[1,1,1,2]]
<strong>输出:</strong>[[1,1,1,1],[1,2,2,2],[1,2,3,3]]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>mat = [[11,25,66,1,69,7],[23,55,17,45,15,52],[75,31,36,44,58,8],[22,27,33,25,68,4],[84,28,14,11,5,50]]
<strong>输出:</strong>[[5,17,4,1,52,7],[11,11,25,45,8,69],[14,23,25,44,58,15],[22,27,31,36,50,66],[84,28,75,33,55,68]]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == mat.length</code></li>
<li><code>n == mat[i].length</code></li>
<li><code>1 <= m, n <= 100</code></li>
<li><code>1 <= mat[i][j] <= 100</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code> 。「数组值」定义为所有满足&nbsp;<code>0 &lt;= i &lt; nums.length-1</code>&nbsp;&nbsp;<code>|nums[i]-nums[i+1]|</code>&nbsp;的和。</p>
<p>你可以选择给定数组的任意子数组,并将该子数组翻转。但你只能执行这个操作&nbsp;<strong>一次</strong></p>
<p>请你找到可行的最大 <strong>数组值&nbsp;</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [2,3,1,5,4]
<strong>输出:</strong>10
<strong>解释:</strong>通过翻转子数组 [3,1,5] ,数组变成 [2,5,1,3,4] ,数组值为 10 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [2,4,9,24,2,1,10]
<strong>输出:</strong>68
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 3*10^4</code></li>
<li><code>-10^5 &lt;= nums[i] &lt;= 10^5</code></li>
</ul>
<p>给你无向&nbsp;<strong><a href="https://baike.baidu.com/item/连通图/6460995?fr=aladdin" target="_blank">连通</a>&nbsp;</strong>图中一个节点的引用,请你返回该图的&nbsp;<a href="https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin" target="_blank"><strong>深拷贝</strong></a>(克隆)。</p>
<p>图中的每个节点都包含它的值 <code>val</code><code>int</code>) 和其邻居的列表(<code>list[Node]</code>)。</p>
<pre>class Node {
public int val;
public List&lt;Node&gt; neighbors;
}</pre>
<p>&nbsp;</p>
<p><strong>测试用例格式:</strong></p>
<p>简单起见,每个节点的值都和它的索引相同。例如,第一个节点值为 1(<code>val = 1</code>),第二个节点值为 2(<code>val = 2</code>),以此类推。该图在测试用例中使用邻接列表表示。</p>
<p><strong>邻接列表</strong> 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。</p>
<p>给定节点将始终是图中的第一个节点(值为 1)。你必须将&nbsp;<strong>给定节点的拷贝&nbsp;</strong>作为对克隆图的引用返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/133_clone_graph_question.png" style="height: 500px; width: 500px;"></p>
<pre><strong>输入:</strong>adjList = [[2,4],[1,3],[2,4],[1,3]]
<strong>输出:</strong>[[2,4],[1,3],[2,4],[1,3]]
<strong>解释:
</strong>图中有 4 个节点。
节点 1 的值是 1,它有两个邻居:节点 2 和 4 。
节点 2 的值是 2,它有两个邻居:节点 1 和 3 。
节点 3 的值是 3,它有两个邻居:节点 2 和 4 。
节点 4 的值是 4,它有两个邻居:节点 1 和 3 。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph.png" style="height: 148px; width: 163px;"></p>
<pre><strong>输入:</strong>adjList = [[]]
<strong>输出:</strong>[[]]
<strong>解释:</strong>输入包含一个空列表。该图仅仅只有一个值为 1 的节点,它没有任何邻居。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>adjList = []
<strong>输出:</strong>[]
<strong>解释:</strong>这个图是空的,它不含任何节点。
</pre>
<p><strong>示例 4:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph-1.png" style="height: 133px; width: 272px;"></p>
<pre><strong>输入:</strong>adjList = [[2],[1]]
<strong>输出:</strong>[[2],[1]]</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ol>
<li>节点数不超过 100 。</li>
<li>每个节点值&nbsp;<code>Node.val</code> 都是唯一的,<code>1 &lt;= Node.val &lt;= 100</code></li>
<li>无向图是一个<a href="https://baike.baidu.com/item/简单图/1680528?fr=aladdin" target="_blank">简单图</a>,这意味着图中没有重复的边,也没有自环。</li>
<li>由于图是无向的,如果节点 <em>p</em> 是节点 <em>q</em> 的邻居,那么节点 <em>q</em> 也必须是节点 <em>p</em>&nbsp;的邻居。</li>
<li>图是连通图,你可以从给定节点访问到所有节点。</li>
</ol>
<p>给你一个整数数组&nbsp;<code>arr</code> ,请你将数组中的每个元素替换为它们排序后的序号。</p>
<p>序号代表了一个元素有多大。序号编号的规则如下:</p>
<ul>
<li>序号从 1 开始编号。</li>
<li>一个元素越大,那么序号越大。如果两个元素相等,那么它们的序号相同。</li>
<li>每个数字的序号都应该尽可能地小。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [40,10,20,30]
<strong>输出:</strong>[4,1,2,3]
<strong>解释:</strong>40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [100,100,100]
<strong>输出:</strong>[1,1,1]
<strong>解释:</strong>所有元素有相同的序号。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [37,12,28,9,100,56,80,5,12]
<strong>输出:</strong>[5,3,4,2,8,6,7,1,3]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 &lt;= arr.length &lt;= 10<sup>5</sup></code></li>
<li><code>-10<sup>9</sup>&nbsp;&lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>,它仅由字母&nbsp;<code>'a'</code><code>'b'</code>&nbsp;组成。每一次删除操作都可以从 <code>s</code> 中删除一个回文 <strong>子序列</strong></p>
<p>返回删除给定字符串中所有字符(字符串为空)的最小删除次数。</p>
<p>「子序列」定义:如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到,那么这个字符串就是原字符串的一个子序列。</p>
<p>「回文」定义:如果一个字符串向后和向前读是一致的,那么这个字符串就是一个回文。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "ababa"
<strong>输出:</strong>1
<strong>解释:</strong>字符串本身就是回文序列,只需要删除一次。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "abb"
<strong>输出:</strong>2
<strong>解释:</strong>"<strong>a</strong>bb" -&gt; "<strong>bb</strong>" -&gt; "".
先删除回文子序列 "a",然后再删除 "bb"。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "baabb"
<strong>输出:</strong>2
<strong>解释:</strong>"<strong>baa</strong>b<strong>b</strong>" -&gt; "b" -&gt; "".
先删除回文子序列 "baab",然后再删除 "b"。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 1000</code></li>
<li><code>s</code> 仅包含字母&nbsp;<code>'a'</code>&nbsp;<code>'b'</code></li>
</ul>
<p>给你一个餐馆信息数组&nbsp;<code>restaurants</code>,其中&nbsp;&nbsp;<code>restaurants[i] = [id<sub>i</sub>, rating<sub>i</sub>, veganFriendly<sub>i</sub>, price<sub>i</sub>, distance<sub>i</sub>]</code>。你必须使用以下三个过滤器来过滤这些餐馆信息。</p>
<p>其中素食者友好过滤器&nbsp;<code>veganFriendly</code>&nbsp;的值可以为 <code>true</code> 或者 <code>false</code>,如果为 <em>true</em>&nbsp;就意味着你应该只包括&nbsp;<code>veganFriendly<sub>i</sub></code>&nbsp;为 true 的餐馆,为&nbsp;<em>false</em>&nbsp;则意味着可以包括任何餐馆。此外,我们还有最大价格&nbsp;<code>maxPrice</code>&nbsp;和最大距离&nbsp;<code>maxDistance</code>&nbsp;两个过滤器,它们分别考虑餐厅的价格因素和距离因素的最大值。</p>
<p>过滤后返回餐馆的 <strong><em>id</em></strong>,按照 <em><strong>rating</strong></em>&nbsp;从高到低排序。如果 <em><strong>rating</strong></em> 相同,那么按 <em><strong>id</strong></em> 从高到低排序。简单起见,&nbsp;<code>veganFriendly<sub>i</sub></code><code>veganFriendly</code>&nbsp;&nbsp;<em>true</em>&nbsp;时取值为 <em>1</em>,为 <em>false</em> 时,取值为&nbsp;<em>0 。</em></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 1, maxPrice = 50, maxDistance = 10
<strong>输出:</strong>[3,1,5]
<strong>解释:
</strong>这些餐馆为:
餐馆 1 [id=1, rating=4, veganFriendly=1, price=40, distance=10]
餐馆 2 [id=2, rating=8, veganFriendly=0, price=50, distance=5]
餐馆 3 [id=3, rating=8, veganFriendly=1, price=30, distance=4]
餐馆 4 [id=4, rating=10, veganFriendly=0, price=10, distance=3]
餐馆 5 [id=5, rating=1, veganFriendly=1, price=15, distance=1]
在按照 veganFriendly = 1, maxPrice = 50 和 maxDistance = 10 进行过滤后,我们得到了餐馆 3, 餐馆 1 和 餐馆 5(按评分从高到低排序)。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 0, maxPrice = 50, maxDistance = 10
<strong>输出:</strong>[4,3,2,1,5]
<strong>解释:</strong>餐馆与示例 1 相同,但在 veganFriendly = 0 的过滤条件下,应该考虑所有餐馆。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 0, maxPrice = 30, maxDistance = 3
<strong>输出:</strong>[4,5]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;restaurants.length &lt;= 10^4</code></li>
<li><code>restaurants[i].length == 5</code></li>
<li><code>1 &lt;=&nbsp;id<sub>i</sub>, rating<sub>i</sub>, price<sub>i</sub>, distance<sub>i </sub>&lt;= 10^5</code></li>
<li><code>1 &lt;=&nbsp;maxPrice,&nbsp;maxDistance &lt;= 10^5</code></li>
<li><code>veganFriendly<sub>i</sub></code>&nbsp;<code>veganFriendly</code>&nbsp;的值为 0 或 1 。</li>
<li>所有 <code>id<sub>i</sub></code> 各不相同。</li>
</ul>
<p><code>n</code> 个城市,按从 <code>0</code><code>n-1</code> 编号。给你一个边数组 <code>edges</code>,其中 <code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>, weight<sub>i</sub>]</code> 代表 <code>from<sub>i</sub></code> 和 <code>to<sub>i</sub></code><sub> </sub>两个城市之间的双向加权边,距离阈值是一个整数 <code>distanceThreshold</code></p>
<p>返回能通过某些路径到达其他城市数目最少、且路径距离 <strong>最大</strong> 为 <code>distanceThreshold</code> 的城市。如果有多个这样的城市,则返回编号最大的城市。</p>
<p>注意,连接城市 <em><strong>i</strong></em><em><strong>j</strong></em> 的路径的距离等于沿该路径的所有边的权重之和。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/26/find_the_city_01.png" style="height: 225px; width: 300px;" /></p>
<pre>
<strong>输入:</strong>n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4
<strong>输出:</strong>3
<strong>解释:</strong>城市分布图如上。
每个城市阈值距离 distanceThreshold = 4 内的邻居城市分别是:
城市 0 -> [城市 1, 城市 2] 
城市 1 -> [城市 0, 城市 2, 城市 3] 
城市 2 -> [城市 0, 城市 1, 城市 3] 
城市 3 -> [城市 1, 城市 2] 
城市 0 和 3 在阈值距离 4 以内都有 2 个邻居城市,但是我们必须返回城市 3,因为它的编号最大。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/26/find_the_city_02.png" style="height: 225px; width: 300px;" /></strong></p>
<pre>
<strong>输入:</strong>n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2
<strong>输出:</strong>0
<strong>解释:</strong>城市分布图如上。 
每个城市阈值距离 distanceThreshold = 2 内的邻居城市分别是:
城市 0 -> [城市 1] 
城市 1 -> [城市 0, 城市 4] 
城市 2 -> [城市 3, 城市 4] 
城市 3 -> [城市 2, 城市 4]
城市 4 -> [城市 1, 城市 2, 城市 3] 
城市 0 在阈值距离 2 以内只有 1 个邻居城市。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 <= n <= 100</code></li>
<li><code>1 <= edges.length <= n * (n - 1) / 2</code></li>
<li><code>edges[i].length == 3</code></li>
<li><code>0 <= from<sub>i</sub> < to<sub>i</sub> < n</code></li>
<li><code>1 <= weight<sub>i</sub>, distanceThreshold <= 10^4</code></li>
<li>所有 <code>(from<sub>i</sub>, to<sub>i</sub>)</code> 都是不同的。</li>
</ul>
<p>你需要制定一份&nbsp;<code>d</code>&nbsp;天的工作计划表。工作之间存在依赖,要想执行第&nbsp;<code>i</code>&nbsp;项工作,你必须完成全部&nbsp;<code>j</code>&nbsp;项工作(&nbsp;<code>0 &lt;= j &lt; i</code>)。</p>
<p>你每天 <strong>至少</strong>&nbsp;需要完成一项任务。工作计划的总难度是这&nbsp;<code>d</code>&nbsp;天每一天的难度之和,而一天的工作难度是当天应该完成工作的最大难度。</p>
<p>给你一个整数数组&nbsp;<code>jobDifficulty</code>&nbsp;和一个整数&nbsp;<code>d</code>,分别代表工作难度和需要计划的天数。第&nbsp;<code>i</code>&nbsp;项工作的难度是&nbsp;<code>jobDifficulty[i]</code></p>
<p>返回整个工作计划的 <strong>最小难度</strong> 。如果无法制定工作计划,则返回&nbsp;<strong>-1&nbsp;</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/26/untitled.png" style="height: 304px; width: 365px;"></p>
<pre><strong>输入:</strong>jobDifficulty = [6,5,4,3,2,1], d = 2
<strong>输出:</strong>7
<strong>解释:</strong>第一天,您可以完成前 5 项工作,总难度 = 6.
第二天,您可以完成最后一项工作,总难度 = 1.
计划表的难度 = 6 + 1 = 7
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>jobDifficulty = [9,9,9], d = 4
<strong>输出:</strong>-1
<strong>解释:</strong>就算你每天完成一项工作,仍然有一天是空闲的,你无法制定一份能够满足既定工作时间的计划表。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>jobDifficulty = [1,1,1], d = 3
<strong>输出:</strong>3
<strong>解释:</strong>工作计划为每天一项工作,总难度为 3 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>jobDifficulty = [7,1,7,1,7,1], d = 3
<strong>输出:</strong>15
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>jobDifficulty = [11,111,22,222,33,333,44,444], d = 6
<strong>输出:</strong>843
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= jobDifficulty.length &lt;= 300</code></li>
<li><code>0 &lt;=&nbsp;jobDifficulty[i] &lt;= 1000</code></li>
<li><code>1 &lt;= d &lt;= 10</code></li>
</ul>
<p>给你一个大小为 <code>m * n</code> 的矩阵 <code>mat</code>,矩阵由若干军人和平民组成,分别用 1 和 0 表示。</p>
<p>请你返回矩阵中战斗力最弱的 <code>k</code> 行的索引,按从最弱到最强排序。</p>
<p>如果第 <em><strong>i</strong></em> 行的军人数量少于第 <em><strong>j</strong></em> 行,或者两行军人数量相同但<em><strong> i</strong></em> 小于 <em><strong>j</strong></em>,那么我们认为第<em><strong> i </strong></em>行的战斗力比第<em><strong> j </strong></em>行弱。</p>
<p>军人 <strong>总是</strong> 排在一行中的靠前位置,也就是说 1 总是出现在 0 之前。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>mat =
[[1,1,0,0,0],
[1,1,1,1,0],
[1,0,0,0,0],
[1,1,0,0,0],
[1,1,1,1,1]],
k = 3
<strong>输出:</strong>[2,0,3]
<strong>解释:</strong>
每行中的军人数目:
行 0 -> 2
行 1 -> 4
行 2 -> 1
行 3 -> 2
行 4 -> 5
从最弱到最强对这些行排序后得到 [2,0,3,1,4]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>mat =
[[1,0,0,0],
 [1,1,1,1],
 [1,0,0,0],
 [1,0,0,0]],
k = 2
<strong>输出:</strong>[0,2]
<strong>解释:</strong>
每行中的军人数目:
行 0 -> 1
行 1 -> 4
行 2 -> 1
行 3 -> 1
从最弱到最强对这些行排序后得到 [0,2,3,1]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == mat.length</code></li>
<li><code>n == mat[i].length</code></li>
<li><code>2 <= n, m <= 100</code></li>
<li><code>1 <= k <= m</code></li>
<li><code>matrix[i][j]</code> 不是 0 就是 1</li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>。你可以从中选出一个整数集合,并删除这些整数在数组中的每次出现。</p>
<p>返回&nbsp;<strong>至少</strong>&nbsp;能删除数组中的一半整数的整数集合的最小大小。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [3,3,3,3,5,5,5,2,2,7]
<strong>输出:</strong>2
<strong>解释:</strong>选择 {3,7} 使得结果数组为 [5,5,5,2,2]、长度为 5(原数组长度的一半)。
大小为 2 的可行集合有 {3,5},{3,2},{5,2}。
选择 {2,7} 是不可行的,它的结果数组为 [3,3,3,3,5,5,5],新数组长度大于原数组的二分之一。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [7,7,7,7,7,7]
<strong>输出:</strong>1
<strong>解释:</strong>我们只能选择集合 {7},结果数组为空。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [1,9]
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [1000,1000,3,7]
<strong>输出:</strong>1
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4,5,6,7,8,9,10]
<strong>输出:</strong>5
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>arr.length</code>&nbsp;为偶数</li>
<li><code>1 &lt;= arr[i] &lt;= 10^5</code></li>
</ul>
<p>给你一棵二叉树,它的根为&nbsp;<code>root</code> 。请你删除 1 条边,使二叉树分裂成两棵子树,且它们子树和的乘积尽可能大。</p>
<p>由于答案可能会很大,请你将结果对 10^9 + 7 取模后再返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/02/sample_1_1699.png" style="height: 200px; width: 495px;"></strong></p>
<pre><strong>输入:</strong>root = [1,2,3,4,5,6]
<strong>输出:</strong>110
<strong>解释:</strong>删除红色的边,得到 2 棵子树,和分别为 11 和 10 。它们的乘积是 110 (11*10)
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/02/sample_2_1699.png" style="height: 200px; width: 495px;"></p>
<pre><strong>输入:</strong>root = [1,null,2,3,4,null,null,5,6]
<strong>输出:</strong>90
<strong>解释:</strong>移除红色的边,得到 2 棵子树,和分别是 15 和 6 。它们的乘积为 90 (15*6)
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>root = [2,3,9,10,7,8,6,5,4,11,1]
<strong>输出:</strong>1025
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>root = [1,1]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>每棵树最多有&nbsp;<code>50000</code>&nbsp;个节点,且至少有&nbsp;<code>2</code>&nbsp;个节点。</li>
<li>每个节点的值在&nbsp;<code>[1, 10000]</code>&nbsp;之间。</li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code> 和一个整数&nbsp;<code>d</code> 。每一步你可以从下标&nbsp;<code>i</code>&nbsp;跳到:</p>
<ul>
<li><code>i + x</code>&nbsp;,其中&nbsp;<code>i + x &lt; arr.length</code>&nbsp;&nbsp;<code>0 &lt; x &lt;= d</code>&nbsp;</li>
<li><code>i - x</code>&nbsp;,其中&nbsp;<code>i - x &gt;= 0</code>&nbsp;&nbsp;<code>0 &lt; x &lt;= d</code>&nbsp;</li>
</ul>
<p>除此以外,你从下标&nbsp;<code>i</code> 跳到下标 <code>j</code>&nbsp;需要满足:<code>arr[i] &gt; arr[j]</code>&nbsp;<code>arr[i] &gt; arr[k]</code>&nbsp;,其中下标&nbsp;<code>k</code>&nbsp;是所有 <code>i</code>&nbsp;<code>j</code>&nbsp;之间的数字(更正式的,<code>min(i, j) &lt; k &lt; max(i, j)</code>)。</p>
<p>你可以选择数组的任意下标开始跳跃。请你返回你 <strong>最多</strong>&nbsp;可以访问多少个下标。</p>
<p>请注意,任何时刻你都不能跳到数组的外面。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/02/meta-chart.jpeg" style="height: 419px; width: 633px;"></p>
<pre><strong>输入:</strong>arr = [6,4,14,6,8,13,9,7,10,6,12], d = 2
<strong>输出:</strong>4
<strong>解释:</strong>你可以从下标 10 出发,然后如上图依次经过 10 --&gt; 8 --&gt; 6 --&gt; 7 。
注意,如果你从下标 6 开始,你只能跳到下标 7 处。你不能跳到下标 5 处因为 13 &gt; 9 。你也不能跳到下标 4 处,因为下标 5 在下标 4 和 6 之间且 13 &gt; 9 。
类似的,你不能从下标 3 处跳到下标 2 或者下标 1 处。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [3,3,3,3,3], d = 3
<strong>输出:</strong>1
<strong>解释:</strong>你可以从任意下标处开始且你永远无法跳到任何其他坐标。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [7,6,5,4,3,2,1], d = 1
<strong>输出:</strong>7
<strong>解释:</strong>从下标 0 处开始,你可以按照数值从大到小,访问所有的下标。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [7,1,7,1,7,1], d = 2
<strong>输出:</strong>2
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [66], d = 1
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 1000</code></li>
<li><code>1 &lt;= arr[i] &lt;= 10^5</code></li>
<li><code>1 &lt;= d &lt;= arr.length</code></li>
</ul>
<p>在一条环路上有&nbsp;<em>N</em>&nbsp;个加油站,其中第&nbsp;<em>i</em>&nbsp;个加油站有汽油&nbsp;<code>gas[i]</code><em>&nbsp;</em>升。</p>
<p>你有一辆油箱容量无限的的汽车,从第<em> i </em>个加油站开往第<em> i+1&nbsp;</em>个加油站需要消耗汽油&nbsp;<code>cost[i]</code><em>&nbsp;</em>升。你从其中的一个加油站出发,开始时油箱为空。</p>
<p>如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 -1。</p>
<p><strong>说明:</strong>&nbsp;</p>
<ul>
<li>如果题目有解,该答案即为唯一答案。</li>
<li>输入数组均为非空数组,且长度相同。</li>
<li>输入数组中的元素均为非负数。</li>
</ul>
<p><strong>示例&nbsp;1:</strong></p>
<pre><strong>输入:</strong>
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
<strong>输出:</strong> 3
<strong>解释:
</strong>从 3 号加油站(索引为 3 处)出发,可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站,此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站,此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站,此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站,此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站,你需要消耗 5 升汽油,正好足够你返回到 3 号加油站。
因此,3 可为起始索引。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>
gas = [2,3,4]
cost = [3,4,3]
<strong>输出:</strong> -1
<strong>解释:
</strong>你不能从 0 号或 1 号加油站出发,因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发,可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站,此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站,此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站,因为返程需要消耗 4 升汽油,但是你的油箱只有 3 升汽油。
因此,无论怎样,你都不可能绕环路行驶一周。</pre>
<p>给你一个非负整数&nbsp;<code>num</code>&nbsp;,请你返回将它变成 0 所需要的步数。 如果当前数字是偶数,你需要把它除以 2 ;否则,减去 1 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>num = 14
<strong>输出:</strong>6
<strong>解释:
</strong>步骤 1) 14 是偶数,除以 2 得到 7 。
步骤 2) 7 是奇数,减 1 得到 6 。
步骤 3) 6 是偶数,除以 2 得到 3 。
步骤 4) 3 是奇数,减 1 得到 2 。
步骤 5) 2 是偶数,除以 2 得到 1 。
步骤 6) 1 是奇数,减 1 得到 0 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>num = 8
<strong>输出:</strong>4
<strong>解释:</strong>
步骤 1) 8 是偶数,除以 2 得到 4 。
步骤 2) 4 是偶数,除以 2 得到 2 。
步骤 3) 2 是偶数,除以 2 得到 1 。
步骤 4) 1 是奇数,减 1 得到 0 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>num = 123
<strong>输出:</strong>12
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 &lt;= num &lt;= 10^6</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>&nbsp;和两个整数 <code>k</code>&nbsp;<code>threshold</code>&nbsp;</p>
<p>请你返回长度为 <code>k</code>&nbsp;且平均值大于等于&nbsp;<code>threshold</code>&nbsp;的子数组数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [2,2,2,2,5,5,5,8], k = 3, threshold = 4
<strong>输出:</strong>3
<strong>解释:</strong>子数组 [2,5,5],[5,5,5] 和 [5,5,8] 的平均值分别为 4,5 和 6 。其他长度为 3 的子数组的平均值都小于 4 (threshold 的值)。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,1,1,1,1], k = 1, threshold = 0
<strong>输出:</strong>5
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [11,13,17,23,29,31,7,5,2,3], k = 3, threshold = 5
<strong>输出:</strong>6
<strong>解释:</strong>前 6 个长度为 3 的子数组平均值都大于 5 。注意平均值不是整数。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [7,7,7,7,7,7,7], k = 7, threshold = 7
<strong>输出:</strong>1
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [4,4,4,4], k = 4, threshold = 1
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>1 &lt;= arr[i] &lt;= 10^4</code></li>
<li><code>1 &lt;= k &lt;= arr.length</code></li>
<li><code>0 &lt;= threshold &lt;= 10^4</code></li>
</ul>
<p>给你两个数&nbsp;<code>hour</code>&nbsp;&nbsp;<code>minutes</code>&nbsp;。请你返回在时钟上,由给定时间的时针和分针组成的较小角的角度(60 单位制)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/08/sample_1_1673.png" style="height: 225px; width: 230px;"></p>
<pre><strong>输入:</strong>hour = 12, minutes = 30
<strong>输出:</strong>165
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/08/sample_2_1673.png" style="height: 225px; width: 230px;"></p>
<pre><strong>输入:</strong>hour = 3, minutes = 30
<strong>输出;</strong>75
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/08/sample_3_1673.png" style="height: 231px; width: 230px;"></strong></p>
<pre><strong>输入:</strong>hour = 3, minutes = 15
<strong>输出:</strong>7.5
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>hour = 4, minutes = 50
<strong>输出:</strong>155
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>hour = 12, minutes = 0
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= hour &lt;= 12</code></li>
<li><code>0 &lt;= minutes &lt;= 59</code></li>
<li>与标准答案误差在&nbsp;<code>10^-5</code>&nbsp;以内的结果都被视为正确结果。</li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>&nbsp;,你一开始在数组的第一个元素处(下标为 0)。</p>
<p>每一步,你可以从下标&nbsp;<code>i</code>&nbsp;跳到下标:</p>
<ul>
<li><code>i + 1</code>&nbsp;满足:<code>i + 1 &lt; arr.length</code></li>
<li><code>i - 1</code>&nbsp;满足:<code>i - 1 &gt;= 0</code></li>
<li><code>j</code>&nbsp;满足:<code>arr[i] == arr[j]</code>&nbsp;&nbsp;<code>i != j</code></li>
</ul>
<p>请你返回到达数组最后一个元素的下标处所需的&nbsp;<strong>最少操作次数</strong>&nbsp;</p>
<p>注意:任何时候你都不能跳到数组外面。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [100,-23,-23,404,100,23,23,23,3,404]
<strong>输出:</strong>3
<strong>解释:</strong>那你需要跳跃 3 次,下标依次为 0 --&gt; 4 --&gt; 3 --&gt; 9 。下标 9 为数组的最后一个元素的下标。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [7]
<strong>输出:</strong>0
<strong>解释:</strong>一开始就在最后一个元素处,所以你不需要跳跃。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [7,6,9,6,9,6,9,7]
<strong>输出:</strong>1
<strong>解释:</strong>你可以直接从下标 0 处跳到下标 7 处,也就是数组的最后一个元素处。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [6,1,9]
<strong>输出:</strong>2
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [11,22,7,7,7,7,7,7,7,22,13]
<strong>输出:</strong>3
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 5 * 10^4</code></li>
<li><code>-10^8 &lt;= arr[i] &lt;= 10^8</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>,请你检查是否存在两个整数&nbsp;<code>N</code><code>M</code>,满足&nbsp;<code>N</code>&nbsp;&nbsp;<code>M</code>&nbsp;的两倍(即,<code>N = 2 * M</code>)。</p>
<p>更正式地,检查是否存在两个下标&nbsp;<code>i</code><code>j</code> 满足:</p>
<ul>
<li><code>i != j</code></li>
<li><code>0 &lt;= i, j &lt; arr.length</code></li>
<li><code>arr[i] == 2 * arr[j]</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [10,2,5,3]
<strong>输出:</strong>true
<strong>解释:</strong>N<code> = 10</code> 是 M<code> = 5 的两倍</code>,即 <code>10 = 2 * 5 。</code>
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [7,1,14,11]
<strong>输出:</strong>true
<strong>解释:</strong>N<code> = 14</code> 是 M<code> = 7 的两倍</code>,即 <code>14 = 2 * 7 </code>
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [3,1,7,11]
<strong>输出:</strong>false
<strong>解释:</strong>在该情况下不存在 N 和 M 满足 N = 2 * M 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= arr.length &lt;= 500</code></li>
<li><code>-10^3 &lt;= arr[i] &lt;= 10^3</code></li>
</ul>
<p>给你两个长度相等的字符串&nbsp;<code>s</code><code>t</code>。每一个步骤中,你可以选择将&nbsp;<code>t</code>&nbsp;中的 <strong>任一字符</strong> 替换为 <strong>另一个字符</strong></p>
<p>返回使&nbsp;<code>t</code>&nbsp;成为&nbsp;<code>s</code>&nbsp;的字母异位词的最小步骤数。</p>
<p><strong>字母异位词</strong> 指字母相同,但排列不同(也可能相同)的字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输出:</strong>s = &quot;bab&quot;, t = &quot;aba&quot;
<strong>输出:</strong>1
<strong>提示:</strong>&#39;b&#39; 替换 t 中的第一个 &#39;a&#39;,t = &quot;bba&quot; 是 s 的一个字母异位词。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输出:</strong>s = &quot;leetcode&quot;, t = &quot;practice&quot;
<strong>输出:</strong>5
<strong>提示:</strong>用合适的字符替换 t 中的 &#39;p&#39;, &#39;r&#39;, &#39;a&#39;, &#39;i&#39;&#39;c&#39;,使 t 变成 s 的字母异位词。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输出:</strong>s = &quot;anagram&quot;, t = &quot;mangaar&quot;
<strong>输出:</strong>0
<strong>提示:</strong>&quot;anagram&quot;&quot;mangaar&quot; 本身就是一组字母异位词。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输出:</strong>s = &quot;xxyyzz&quot;, t = &quot;xxyyzz&quot;
<strong>输出:</strong>0
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输出:</strong>s = &quot;friend&quot;, t = &quot;family&quot;
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 50000</code></li>
<li><code>s.length == t.length</code></li>
<li><code>s</code><code>t</code>&nbsp;只包含小写英文字母</li>
</ul>
<p>请你实现一个能够支持以下两种方法的推文计数类&nbsp;<code>TweetCounts</code></p>
<p>1.<code> recordTweet(string tweetName, int time)</code></p>
<ul>
<li>记录推文发布情况:用户&nbsp;<code>tweetName</code>&nbsp;&nbsp;<code>time</code>(以 <strong></strong>&nbsp;为单位)时刻发布了一条推文。</li>
</ul>
<p>2.<code> getTweetCountsPerFrequency(string freq, string tweetName, int startTime, int endTime)</code></p>
<ul>
<li>返回从开始时间&nbsp;<code>startTime</code>(以 <strong></strong> 为单位)到结束时间&nbsp;<code>endTime</code>(以 <strong></strong> 为单位)内,每 <strong>&nbsp;</strong><em><strong>minute</strong></em><strong>&nbsp;<em>hour </em></strong>或者 <strong><em>&nbsp;day&nbsp;</em></strong>(取决于&nbsp;<code>freq</code>)内指定用户&nbsp;<code>tweetName</code>&nbsp;发布的推文总数。</li>
<li><code>freq</code>&nbsp;的值始终为 <strong>&nbsp;</strong><em><strong>minute</strong></em><strong></strong><em><strong> hour</strong>&nbsp;</em>或者<em>&nbsp;</em><strong></strong><em><strong> day</strong>&nbsp;</em>之一,表示获取指定用户&nbsp;<code>tweetName</code>&nbsp;发布推文次数的时间间隔。</li>
<li>第一个时间间隔始终从 <code>startTime</code> 开始,因此时间间隔为&nbsp;<code>[startTime, startTime + delta*1&gt;, &nbsp;[startTime + delta*1, startTime + delta*2&gt;, [startTime + delta*2, startTime + delta*3&gt;, ... , [startTime + delta*i,&nbsp;<strong>min</strong>(startTime + delta*(i+1), endTime + 1)&gt;</code>,其中 <code>i</code><code>delta</code>(取决于 <code>freq</code>)都是非负整数。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>
[&quot;TweetCounts&quot;,&quot;recordTweet&quot;,&quot;recordTweet&quot;,&quot;recordTweet&quot;,&quot;getTweetCountsPerFrequency&quot;,&quot;getTweetCountsPerFrequency&quot;,&quot;recordTweet&quot;,&quot;getTweetCountsPerFrequency&quot;]
[[],[&quot;tweet3&quot;,0],[&quot;tweet3&quot;,60],[&quot;tweet3&quot;,10],[&quot;minute&quot;,&quot;tweet3&quot;,0,59],[&quot;minute&quot;,&quot;tweet3&quot;,0,60],[&quot;tweet3&quot;,120],[&quot;hour&quot;,&quot;tweet3&quot;,0,210]]
<strong>输出:</strong>
[null,null,null,null,[2],[2,1],null,[4]]
<strong>解释:</strong>
TweetCounts tweetCounts = new TweetCounts();
tweetCounts.recordTweet(&quot;tweet3&quot;, 0);
tweetCounts.recordTweet(&quot;tweet3&quot;, 60);
tweetCounts.recordTweet(&quot;tweet3&quot;, 10); //&nbsp;&quot;tweet3&quot;&nbsp;发布推文的时间分别是&nbsp;0,&nbsp;10&nbsp;&nbsp;60 。
tweetCounts.getTweetCountsPerFrequency(&quot;minute&quot;, &quot;tweet3&quot;, 0, 59); //&nbsp;返回&nbsp;[2]。统计频率是每分钟(60 秒),因此只有一个有效时间间隔 [0,60&gt;&nbsp;-&nbsp;&gt;&nbsp;2&nbsp;条推文。
tweetCounts.getTweetCountsPerFrequency(&quot;minute&quot;, &quot;tweet3&quot;, 0, 60); //&nbsp;返回&nbsp;[2,1]。统计频率是每分钟(60 秒),因此有两个有效时间间隔&nbsp;<strong>1)</strong>&nbsp;[0,60&gt;&nbsp;-&nbsp;&gt;&nbsp;2&nbsp;条推文,和&nbsp;<strong>2)</strong>&nbsp;[60,61&gt;&nbsp;-&nbsp;&gt;&nbsp;1&nbsp;条推文。
tweetCounts.recordTweet(&quot;tweet3&quot;, 120); // &quot;tweet3&quot;&nbsp;发布推文的时间分别是 0, 10, 60 和 120 。
tweetCounts.getTweetCountsPerFrequency(&quot;hour&quot;, &quot;tweet3&quot;, 0, 210); //&nbsp;返回&nbsp;[4]。统计频率是每小时(3600 秒),因此只有一个有效时间间隔 [0,211&gt;&nbsp;-&nbsp;&gt;&nbsp;4&nbsp;条推文。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>同时考虑&nbsp;<code>recordTweet</code>&nbsp;&nbsp;<code>getTweetCountsPerFrequency</code>,最多有 <code>10000</code> 次操作。</li>
<li><code>0 &lt;= time, startTime, endTime &lt;=&nbsp;10^9</code></li>
<li><code>0 &lt;= endTime - startTime &lt;= 10^4</code></li>
</ul>
<p>给你一个&nbsp;<code>m&nbsp;* n</code>&nbsp;的矩阵 <code>seats</code>&nbsp;表示教室中的座位分布。如果座位是坏的(不可用),就用&nbsp;<code>&#39;#&#39;</code>&nbsp;表示;否则,用&nbsp;<code>&#39;.&#39;</code>&nbsp;表示。</p>
<p>学生可以看到左侧、右侧、左上、右上这四个方向上紧邻他的学生的答卷,但是看不到直接坐在他前面或者后面的学生的答卷。请你计算并返回该考场可以容纳的一起参加考试且无法作弊的最大学生人数。</p>
<p>学生必须坐在状况良好的座位上。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/09/image.png" style="height: 197px; width: 339px;"></p>
<pre><strong>输入:</strong>seats = [[&quot;#&quot;,&quot;.&quot;,&quot;#&quot;,&quot;#&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;.&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;#&quot;,&quot;.&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;#&quot;,&quot;#&quot;,&quot;.&quot;,&quot;#&quot;]]
<strong>输出:</strong>4
<strong>解释:</strong>教师可以让 4 个学生坐在可用的座位上,这样他们就无法在考试中作弊。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>seats = [[&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;],
&nbsp; [&quot;#&quot;,&quot;#&quot;],
&nbsp; [&quot;.&quot;,&quot;#&quot;]]
<strong>输出:</strong>3
<strong>解释:</strong>让所有学生坐在可用的座位上。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>seats = [[&quot;#&quot;,&quot;.&quot;,&quot;<strong>.</strong>&quot;,&quot;.&quot;,&quot;#&quot;],
&nbsp; [&quot;<strong>.</strong>&quot;,&quot;#&quot;,&quot;<strong>.</strong>&quot;,&quot;#&quot;,&quot;<strong>.</strong>&quot;],
&nbsp; [&quot;<strong>.</strong>&quot;,&quot;.&quot;,&quot;#&quot;,&quot;.&quot;,&quot;<strong>.</strong>&quot;],
&nbsp; [&quot;<strong>.</strong>&quot;,&quot;#&quot;,&quot;<strong>.</strong>&quot;,&quot;#&quot;,&quot;<strong>.</strong>&quot;],
&nbsp; [&quot;#&quot;,&quot;.&quot;,&quot;<strong>.</strong>&quot;,&quot;.&quot;,&quot;#&quot;]]
<strong>输出:</strong>10
<strong>解释:</strong>让学生坐在第 1、3 和 5 列的可用座位上。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>seats</code>&nbsp;只包含字符&nbsp;<code>&#39;.&#39;&nbsp;</code><code>&#39;#&#39;</code></li>
<li><code>m ==&nbsp;seats.length</code></li>
<li><code>n ==&nbsp;seats[i].length</code></li>
<li><code>1 &lt;= m &lt;= 8</code></li>
<li><code>1 &lt;= n &lt;= 8</code></li>
</ul>
<p>老师想给孩子们分发糖果,有 <em>N</em> 个孩子站成了一条直线,老师会根据每个孩子的表现,预先给他们评分。</p>
<p>你需要按照以下要求,帮助老师给这些孩子分发糖果:</p>
<ul>
<li>每个孩子至少分配到 1 个糖果。</li>
<li>评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。</li>
</ul>
<p>那么这样下来,老师至少需要准备多少颗糖果呢?</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>[1,0,2]
<strong>输出:</strong>5
<strong>解释:</strong>你可以分别给这三个孩子分发 2、1、2 颗糖果。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>[1,2,2]
<strong>输出:</strong>4
<strong>解释:</strong>你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果,这已满足上述两个条件。</pre>
<p>给你一个 <code>m * n</code> 的矩阵 <code>grid</code>,矩阵中的元素无论是按行还是按列,都以非递增顺序排列。 </p>
<p>请你统计并返回 <code>grid</code> 中 <strong>负数</strong> 的数目。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
<strong>输出:</strong>8
<strong>解释:</strong>矩阵中共有 8 个负数。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>grid = [[3,2],[1,0]]
<strong>输出:</strong>0
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>grid = [[1,-1],[-1,-1]]
<strong>输出:</strong>3
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>grid = [[-1]]
<strong>输出:</strong>1
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == grid.length</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>1 <= m, n <= 100</code></li>
<li><code>-100 <= grid[i][j] <= 100</code></li>
</ul>
<p> </p>
<p><strong>进阶:</strong>你可以设计一个时间复杂度为 <code>O(n + m)</code> 的解决方案吗?</p>
<p> </p>
<p>请你实现一个「数字乘积类」<code>ProductOfNumbers</code>,要求支持下述两种方法:</p>
<p>1.<code>&nbsp;add(int num)</code></p>
<ul>
<li>将数字&nbsp;<code>num</code>&nbsp;添加到当前数字列表的最后面。</li>
</ul>
<p>2.<code> getProduct(int k)</code></p>
<ul>
<li>返回当前数字列表中,最后&nbsp;<code>k</code>&nbsp;个数字的乘积。</li>
<li>你可以假设当前列表中始终 <strong>至少</strong> 包含 <code>k</code> 个数字。</li>
</ul>
<p>题目数据保证:任何时候,任一连续数字序列的乘积都在 32-bit 整数范围内,不会溢出。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>
[&quot;ProductOfNumbers&quot;,&quot;add&quot;,&quot;add&quot;,&quot;add&quot;,&quot;add&quot;,&quot;add&quot;,&quot;getProduct&quot;,&quot;getProduct&quot;,&quot;getProduct&quot;,&quot;add&quot;,&quot;getProduct&quot;]
[[],[3],[0],[2],[5],[4],[2],[3],[4],[8],[2]]
<strong>输出:</strong>
[null,null,null,null,null,null,20,40,0,null,32]
<strong>解释:</strong>
ProductOfNumbers productOfNumbers = new ProductOfNumbers();
productOfNumbers.add(3); // [3]
productOfNumbers.add(0); // [3,0]
productOfNumbers.add(2); // [3,0,2]
productOfNumbers.add(5); // [3,0,2,5]
productOfNumbers.add(4); // [3,0,2,5,4]
productOfNumbers.getProduct(2); // 返回 20 。最后 2 个数字的乘积是 5 * 4 = 20
productOfNumbers.getProduct(3); // 返回 40 。最后 3 个数字的乘积是 2 * 5 * 4 = 40
productOfNumbers.getProduct(4); // 返回 0 。最后 4 个数字的乘积是 0 * 2 * 5 * 4 = 0
productOfNumbers.add(8); // [3,0,2,5,4,8]
productOfNumbers.getProduct(2); // 返回 32 。最后 2 个数字的乘积是 4 * 8 = 32
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>add</code><code>getProduct</code>&nbsp;两种操作加起来总共不会超过&nbsp;<code>40000</code>&nbsp;次。</li>
<li><code>0 &lt;= num&nbsp;&lt;=&nbsp;100</code></li>
<li><code>1 &lt;= k &lt;= 40000</code></li>
</ul>
<p>给你一个数组&nbsp;<code>events</code>,其中&nbsp;<code>events[i] = [startDay<sub>i</sub>, endDay<sub>i</sub>]</code>&nbsp;,表示会议&nbsp;<code>i</code>&nbsp;开始于&nbsp;<code>startDay<sub>i</sub></code>&nbsp;,结束于&nbsp;<code>endDay<sub>i</sub></code>&nbsp;</p>
<p>你可以在满足&nbsp;<code>startDay<sub>i</sub>&nbsp;&lt;= d &lt;= endDay<sub>i</sub></code><sub>&nbsp;</sub>中的任意一天&nbsp;<code>d</code>&nbsp;参加会议&nbsp;<code>i</code>&nbsp;。注意,一天只能参加一个会议。</p>
<p>请你返回你可以参加的&nbsp;<strong>最大&nbsp;</strong>会议数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/16/e1.png" style="height: 400px; width: 600px;"></p>
<pre><strong>输入:</strong>events = [[1,2],[2,3],[3,4]]
<strong>输出:</strong>3
<strong>解释:</strong>你可以参加所有的三个会议。
安排会议的一种方案如上图。
第 1 天参加第一个会议。
第 2 天参加第二个会议。
第 3 天参加第三个会议。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>events= [[1,2],[2,3],[3,4],[1,2]]
<strong>输出:</strong>4
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>events = [[1,4],[4,4],[2,2],[3,4],[1,1]]
<strong>输出:</strong>4
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>events = [[1,100000]]
<strong>输出:</strong>1
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>events = [[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]]
<strong>输出:</strong>7
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= events.length &lt;= 10^5</code></li>
<li><code>events[i].length == 2</code></li>
<li><code>1 &lt;= events[i][0] &lt;= events[i][1] &lt;= 10^5</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>target</code> 。一开始,你有一个数组&nbsp;<code>A</code> ,它的所有元素均为 1 ,你可以执行以下操作:</p>
<ul>
<li>&nbsp;<code>x</code>&nbsp;为你数组里所有元素的和</li>
<li>选择满足&nbsp;<code>0 &lt;= i &lt; target.size</code>&nbsp;的任意下标&nbsp;<code>i</code>&nbsp;,并让&nbsp;<code>A</code>&nbsp;数组里下标为&nbsp;<code>i</code>&nbsp;处的值为&nbsp;<code>x</code>&nbsp;</li>
<li>你可以重复该过程任意次</li>
</ul>
<p>如果能从&nbsp;<code>A</code>&nbsp;开始构造出目标数组&nbsp;<code>target</code>&nbsp;,请你返回 True ,否则返回 False 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>target = [9,3,5]
<strong>输出:</strong>true
<strong>解释:</strong>从 [1, 1, 1] 开始
[1, 1, 1], 和为 3 ,选择下标 1
[1, 3, 1], 和为 5, 选择下标 2
[1, 3, 5], 和为 9, 选择下标 0
[9, 3, 5] 完成
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>target = [1,1,1,2]
<strong>输出:</strong>false
<strong>解释:</strong>不可能从 [1,1,1,1] 出发构造目标数组。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>target = [8,5]
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>N == target.length</code></li>
<li><code>1 &lt;= target.length&nbsp;&lt;= 5 * 10^4</code></li>
<li><code>1 &lt;= target[i] &lt;= 10^9</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>&nbsp;。请你将数组中的元素按照其二进制表示中数字 <strong>1</strong> 的数目升序排序。</p>
<p>如果存在多个数字二进制中&nbsp;<strong>1</strong>&nbsp;的数目相同,则必须将它们按照数值大小升序排列。</p>
<p>请你返回排序后的数组。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [0,1,2,3,4,5,6,7,8]
<strong>输出:</strong>[0,1,2,4,8,3,5,6,7]
<strong>解释:</strong>[0] 是唯一一个有 0 个 1 的数。
[1,2,4,8] 都有 1 个 1 。
[3,5,6] 有 2 个 1 。
[7] 有 3 个 1 。
按照 1 的个数排序得到的结果数组为 [0,1,2,4,8,3,5,6,7]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1024,512,256,128,64,32,16,8,4,2,1]
<strong>输出:</strong>[1,2,4,8,16,32,64,128,256,512,1024]
<strong>解释:</strong>数组中所有整数二进制下都只有 1 个 1 ,所以你需要按照数值大小将它们排序。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [10000,10000]
<strong>输出:</strong>[10000,10000]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [2,3,5,7,11,13,17,19]
<strong>输出:</strong>[2,3,5,17,7,11,13,19]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [10,100,1000,10000]
<strong>输出:</strong>[10,100,10000,1000]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 500</code></li>
<li><code>0 &lt;= arr[i] &lt;= 10^4</code></li>
</ul>
<p>超市里正在举行打折活动,每隔&nbsp;<code>n</code>&nbsp;个顾客会得到 <code>discount</code>&nbsp;的折扣。</p>
<p>超市里有一些商品,第&nbsp;<code>i</code>&nbsp;种商品为&nbsp;<code>products[i]</code>&nbsp;且每件单品的价格为&nbsp;<code>prices[i]</code>&nbsp;</p>
<p>结账系统会统计顾客的数目,每隔&nbsp;<code>n</code>&nbsp;个顾客结账时,该顾客的账单都会打折,折扣为&nbsp;<code>discount</code>&nbsp;(也就是如果原本账单为&nbsp;<code>x</code>&nbsp;,那么实际金额会变成&nbsp;<code>x - (discount * x) / 100</code>&nbsp;),然后系统会重新开始计数。</p>
<p>顾客会购买一些商品,&nbsp;<code>product[i]</code>&nbsp;是顾客购买的第&nbsp;<code>i</code>&nbsp;种商品,&nbsp;<code>amount[i]</code>&nbsp;是对应的购买该种商品的数目。</p>
<p>请你实现&nbsp;<code>Cashier</code>&nbsp;类:</p>
<ul>
<li><code>Cashier(int n, int discount, int[] products, int[] prices)</code>&nbsp;初始化实例对象,参数分别为打折频率&nbsp;<code>n</code>&nbsp;,折扣大小 <code>discount</code>&nbsp;,超市里的商品列表 <code>products</code>&nbsp;和它们的价格 <code>prices</code>&nbsp;</li>
<li><code>double&nbsp;getBill(int[] product, int[] amount)</code>&nbsp;返回账单的实际金额(如果有打折,请返回打折后的结果)。返回结果与标准答案误差在&nbsp;<code>10^-5</code>&nbsp;以内都视为正确结果。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入</strong>
[&quot;Cashier&quot;,&quot;getBill&quot;,&quot;getBill&quot;,&quot;getBill&quot;,&quot;getBill&quot;,&quot;getBill&quot;,&quot;getBill&quot;,&quot;getBill&quot;]
[[3,50,[1,2,3,4,5,6,7],[100,200,300,400,300,200,100]],[[1,2],[1,2]],[[3,7],[10,10]],[[1,2,3,4,5,6,7],[1,1,1,1,1,1,1]],[[4],[10]],[[7,3],[10,10]],[[7,5,3,1,6,4,2],[10,10,10,9,9,9,7]],[[2,3,5],[5,3,2]]]
<strong>输出</strong>
[null,500.0,4000.0,800.0,4000.0,4000.0,7350.0,2500.0]
<strong>解释</strong>
Cashier cashier = new Cashier(3,50,[1,2,3,4,5,6,7],[100,200,300,400,300,200,100]);
cashier.getBill([1,2],[1,2]); // 返回 500.0, 账单金额为 = 1 * 100 + 2 * 200 = 500.
cashier.getBill([3,7],[10,10]); // 返回 4000.0
cashier.getBill([1,2,3,4,5,6,7],[1,1,1,1,1,1,1]); // 返回 800.0 ,账单原本为 1600.0 ,但由于该顾客是第三位顾客,他将得到 50% 的折扣,所以实际金额为 1600 - 1600 * (50 / 100) = 800 。
cashier.getBill([4],[10]); // 返回 4000.0
cashier.getBill([7,3],[10,10]); // 返回 4000.0
cashier.getBill([7,5,3,1,6,4,2],[10,10,10,9,9,9,7]); // 返回 7350.0 ,账单原本为 14700.0 ,但由于系统计数再次达到三,该顾客将得到 50% 的折扣,实际金额为 7350.0 。
cashier.getBill([2,3,5],[5,3,2]); // 返回 2500.0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^4</code></li>
<li><code>0 &lt;= discount &lt;= 100</code></li>
<li><code>1 &lt;= products.length &lt;= 200</code></li>
<li><code>1 &lt;= products[i] &lt;= 200</code></li>
<li><code>products</code>&nbsp;列表中&nbsp;<strong>不会</strong>&nbsp;有重复的元素。</li>
<li><code>prices.length == products.length</code></li>
<li><code>1 &lt;= prices[i] &lt;= 1000</code></li>
<li><code>1 &lt;= product.length &lt;= products.length</code></li>
<li><code>product[i]</code>&nbsp;&nbsp;<code>products</code>&nbsp;出现过。</li>
<li><code>amount.length == product.length</code></li>
<li><code>1 &lt;= amount[i] &lt;= 1000</code></li>
<li>最多有&nbsp;<code>1000</code> 次对&nbsp;<code>getBill</code>&nbsp;函数的调用。</li>
<li>返回结果与标准答案误差在&nbsp;<code>10^-5</code>&nbsp;以内都视为正确结果。</li>
</ul>
<p>给你一个字符串 <code>s</code>&nbsp;,它只包含三种字符 a, b 和 c 。</p>
<p>请你返回 a,b 和 c 都&nbsp;<strong>至少&nbsp;</strong>出现过一次的子字符串数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;abcabc&quot;
<strong>输出:</strong>10
<strong>解释:</strong>包含 a,b 和 c 各至少一次的子字符串为<em> &quot;</em>abc<em>&quot;, &quot;</em>abca<em>&quot;, &quot;</em>abcab<em>&quot;, &quot;</em>abcabc<em>&quot;, &quot;</em>bca<em>&quot;, &quot;</em>bcab<em>&quot;, &quot;</em>bcabc<em>&quot;, &quot;</em>cab<em>&quot;, &quot;</em>cabc<em>&quot; </em><em> &quot;</em>abc<em>&quot; </em>(<strong>相同</strong><strong>字符串算多次</strong>)<em></em>
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaacb&quot;
<strong>输出:</strong>3
<strong>解释:</strong>包含 a,b 和 c 各至少一次的子字符串为<em> &quot;</em>aaacb<em>&quot;, &quot;</em>aacb<em>&quot; </em><em> &quot;</em>acb<em>&quot;</em>
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;abc&quot;
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 &lt;= s.length &lt;= 5 x 10^4</code></li>
<li><code>s</code>&nbsp;只包含字符 a,b 和 c 。</li>
</ul>
<p>给你&nbsp;<code>n</code>&nbsp;笔订单,每笔订单都需要快递服务。</p>
<p>请你统计所有有效的 收件/配送 序列的数目,确保第 <code>i</code> 个物品的配送服务&nbsp;<code>delivery(i)</code> 总是在其收件服务&nbsp;<code>pickup(i)</code> 之后。</p>
<p>由于答案可能很大,请返回答案对 <code>10^9 + 7</code> 取余的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 1
<strong>输出:</strong>1
<strong>解释:</strong>只有一种序列 (P1, D1),物品 1 的配送服务(D1)在物品 1 的收件服务(P1)后。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>6
<strong>解释:</strong>所有可能的序列包括:
(P1,P2,D1,D2),(P1,P2,D2,D1),(P1,D1,P2,D2),(P2,P1,D1,D2),(P2,P1,D2,D1) 和 (P2,D2,P1,D1)。
(P1,D2,P2,D1) 是一个无效的序列,因为物品 2 的收件服务(P2)不应在物品 2 的配送服务(D2)之后。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 3
<strong>输出:</strong>90
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 500</code></li>
</ul>
<p>请你编写一个程序来计算两个日期之间隔了多少天。</p>
<p>日期以字符串形式给出,格式为&nbsp;<code>YYYY-MM-DD</code>,如示例所示。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>date1 = &quot;2019-06-29&quot;, date2 = &quot;2019-06-30&quot;
<strong>输出:</strong>1
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>date1 = &quot;2020-01-15&quot;, date2 = &quot;2019-12-31&quot;
<strong>输出:</strong>15
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>给定的日期是&nbsp;<code>1971</code>&nbsp;年到 <code>2100</code>&nbsp;年之间的有效日期。</li>
</ul>
<p>给定一个<strong>非空</strong>整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。</p>
<p><strong>说明:</strong></p>
<p>你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong> [2,2,1]
<strong>输出:</strong> 1
</pre>
<p><strong>示例&nbsp;2:</strong></p>
<pre><strong>输入:</strong> [4,1,2,1,2]
<strong>输出:</strong> 4</pre>
<p>二叉树上有 <code>n</code>&nbsp;个节点,按从&nbsp;<code>0</code>&nbsp;<code>n - 1</code>&nbsp;编号,其中节点&nbsp;<code>i</code>&nbsp;的两个子节点分别是&nbsp;<code>leftChild[i]</code>&nbsp;&nbsp;<code>rightChild[i]</code></p>
<p>只有 <strong>所有</strong> 节点能够形成且 <strong></strong> 形成 <strong>一颗</strong>&nbsp;有效的二叉树时,返回&nbsp;<code>true</code>;否则返回 <code>false</code></p>
<p>如果节点&nbsp;<code>i</code>&nbsp;没有左子节点,那么&nbsp;<code>leftChild[i]</code>&nbsp;就等于&nbsp;<code>-1</code>。右子节点也符合该规则。</p>
<p>注意:节点没有值,本问题中仅仅使用节点编号。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/23/1503_ex1.png" style="height: 287px; width: 195px;"></strong></p>
<pre><strong>输入:</strong>n = 4, leftChild = [1,-1,3,-1], rightChild = [2,-1,-1,-1]
<strong>输出:</strong>true
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/23/1503_ex2.png" style="height: 272px; width: 183px;"></strong></p>
<pre><strong>输入:</strong>n = 4, leftChild = [1,-1,3,-1], rightChild = [2,3,-1,-1]
<strong>输出:</strong>false
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/23/1503_ex3.png" style="height: 174px; width: 82px;"></strong></p>
<pre><strong>输入:</strong>n = 2, leftChild = [1,0], rightChild = [-1,-1]
<strong>输出:</strong>false
</pre>
<p><strong>示例 4:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/23/1503_ex4.png" style="height: 191px; width: 470px;"></strong></p>
<pre><strong>输入:</strong>n = 6, leftChild = [1,-1,-1,4,-1,-1], rightChild = [2,-1,-1,5,-1,-1]
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^4</code></li>
<li><code>leftChild.length == rightChild.length == n</code></li>
<li><code>-1 &lt;= leftChild[i], rightChild[i] &lt;= n - 1</code></li>
</ul>
<p>给你一个整数&nbsp;<code>num</code>,请你找出同时满足下面全部要求的两个整数:</p>
<ul>
<li>两数乘积等于 &nbsp;<code>num + 1</code>&nbsp;&nbsp;<code>num + 2</code></li>
<li>以绝对差进行度量,两数大小最接近</li>
</ul>
<p>你可以按任意顺序返回这两个整数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>num = 8
<strong>输出:</strong>[3,3]
<strong>解释:</strong>对于 num + 1 = 9,最接近的两个因数是 3 &amp; 3;对于 num + 2 = 10, 最接近的两个因数是 2 &amp; 5,因此返回 3 &amp; 3 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>num = 123
<strong>输出:</strong>[5,25]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>num = 999
<strong>输出:</strong>[40,25]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= num &lt;= 10^9</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>digits</code>,你可以通过按任意顺序连接其中某些数字来形成 <strong>3</strong> 的倍数,请你返回所能得到的最大的 3 的倍数。</p>
<p>由于答案可能不在整数数据类型范围内,请以字符串形式返回答案。</p>
<p>如果无法得到答案,请返回一个空字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>digits = [8,1,9]
<strong>输出:</strong>&quot;981&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>digits = [8,6,7,1,0]
<strong>输出:</strong>&quot;8760&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>digits = [1]
<strong>输出:</strong>&quot;&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>digits = [0,0,0,0,0,0]
<strong>输出:</strong>&quot;0&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= digits.length &lt;= 10^4</code></li>
<li><code>0 &lt;= digits[i] &lt;= 9</code></li>
<li>返回的结果不应包含不必要的前导零。</li>
</ul>
<p>给你一个数组&nbsp;<code>nums</code>,对于其中每个元素&nbsp;<code>nums[i]</code>,请你统计数组中比它小的所有数字的数目。</p>
<p>换而言之,对于每个&nbsp;<code>nums[i]</code>&nbsp;你必须计算出有效的&nbsp;<code>j</code>&nbsp;的数量,其中 <code>j</code> 满足&nbsp;<code>j != i</code> <strong></strong> <code>nums[j] &lt; nums[i]</code>&nbsp;</p>
<p>以数组形式返回答案。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [8,1,2,2,3]
<strong>输出:</strong>[4,0,1,1,3]
<strong>解释:</strong>
对于 nums[0]=8 存在四个比它小的数字:(1,2,2 和 3)。
对于 nums[1]=1 不存在比它小的数字。
对于 nums[2]=2 存在一个比它小的数字:(1)。
对于 nums[3]=2 存在一个比它小的数字:(1)。
对于 nums[4]=3 存在三个比它小的数字:(1,2 和 2)。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [6,5,4,8]
<strong>输出:</strong>[2,1,0,3]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [7,7,7,7]
<strong>输出:</strong>[0,0,0,0]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= nums.length &lt;= 500</code></li>
<li><code>0 &lt;= nums[i] &lt;= 100</code></li>
</ul>
<p>现在有一个特殊的排名系统,依据参赛团队在投票人心中的次序进行排名,每个投票者都需要按从高到低的顺序对参与排名的所有团队进行排位。</p>
<p>排名规则如下:</p>
<ul>
<li>参赛团队的排名次序依照其所获「排位第一」的票的多少决定。如果存在多个团队并列的情况,将继续考虑其「排位第二」的票的数量。以此类推,直到不再存在并列的情况。</li>
<li>如果在考虑完所有投票情况后仍然出现并列现象,则根据团队字母的字母顺序进行排名。</li>
</ul>
<p>给你一个字符串数组&nbsp;<code>votes</code> 代表全体投票者给出的排位情况,请你根据上述排名规则对所有参赛团队进行排名。</p>
<p>请你返回能表示按排名系统 <strong>排序后</strong> 的所有团队排名的字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>votes = [&quot;ABC&quot;,&quot;ACB&quot;,&quot;ABC&quot;,&quot;ACB&quot;,&quot;ACB&quot;]
<strong>输出:</strong>&quot;ACB&quot;
<strong>解释:</strong>A 队获得五票「排位第一」,没有其他队获得「排位第一」,所以 A 队排名第一。
B 队获得两票「排位第二」,三票「排位第三」。
C 队获得三票「排位第二」,两票「排位第三」。
由于 C 队「排位第二」的票数较多,所以 C 队排第二,B 队排第三。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>votes = [&quot;WXYZ&quot;,&quot;XYZW&quot;]
<strong>输出:</strong>&quot;XWYZ&quot;
<strong>解释:</strong>X 队在并列僵局打破后成为排名第一的团队。X 队和 W 队的「排位第一」票数一样,但是 X 队有一票「排位第二」,而 W 没有获得「排位第二」。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>votes = [&quot;ZMNAGUEDSJYLBOPHRQICWFXTVK&quot;]
<strong>输出:</strong>&quot;ZMNAGUEDSJYLBOPHRQICWFXTVK&quot;
<strong>解释:</strong>只有一个投票者,所以排名完全按照他的意愿。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>votes = [&quot;BCA&quot;,&quot;CAB&quot;,&quot;CBA&quot;,&quot;ABC&quot;,&quot;ACB&quot;,&quot;BAC&quot;]
<strong>输出:</strong>&quot;ABC&quot;
<strong>解释:</strong>
A 队获得两票「排位第一」,两票「排位第二」,两票「排位第三」。
B 队获得两票「排位第一」,两票「排位第二」,两票「排位第三」。
C 队获得两票「排位第一」,两票「排位第二」,两票「排位第三」。
完全并列,所以我们需要按照字母升序排名。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>votes = [&quot;M&quot;,&quot;M&quot;,&quot;M&quot;,&quot;M&quot;]
<strong>输出:</strong>&quot;M&quot;
<strong>解释:</strong>只有 M 队参赛,所以它排名第一。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= votes.length &lt;= 1000</code></li>
<li><code>1 &lt;= votes[i].length &lt;= 26</code></li>
<li><code>votes[i].length ==&nbsp;votes[j].length</code> for&nbsp;<code>0 &lt;= i, j &lt; votes.length</code></li>
<li><code>votes[i][j]</code>&nbsp;是英文 <strong>大写</strong> 字母</li>
<li><code>votes[i]</code>&nbsp;中的所有字母都是唯一的</li>
<li><code>votes[0]</code>&nbsp;中出现的所有字母 <strong>同样也</strong> 出现在&nbsp;<code>votes[j]</code>&nbsp;中,其中&nbsp;<code>1 &lt;= j &lt; votes.length</code></li>
</ul>
<p>给你一棵以&nbsp;<code>root</code>&nbsp;为根的二叉树和一个&nbsp;<code>head</code>&nbsp;为第一个节点的链表。</p>
<p>如果在二叉树中,存在一条一直向下的路径,且每个点的数值恰好一一对应以&nbsp;<code>head</code>&nbsp;为首的链表中每个节点的值,那么请你返回 <code>True</code> ,否则返回 <code>False</code></p>
<p>一直向下的路径的意思是:从树中某个节点开始,一直连续向下的路径。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/29/sample_1_1720.png" style="height: 280px; width: 220px;"></strong></p>
<pre><strong>输入:</strong>head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
<strong>输出:</strong>true
<strong>解释:</strong>树中蓝色的节点构成了与链表对应的子路径。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/29/sample_2_1720.png" style="height: 280px; width: 220px;"></strong></p>
<pre><strong>输入:</strong>head = [1,4,2,6], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
<strong>输出:</strong>true
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>head = [1,4,2,6,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
<strong>输出:</strong>false
<strong>解释:</strong>二叉树中不存在一一对应链表的路径。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>二叉树和链表中的每个节点的值都满足&nbsp;<code>1 &lt;= node.val&nbsp;&lt;= 100</code>&nbsp;</li>
<li>链表包含的节点数目在&nbsp;<code>1</code>&nbsp;&nbsp;<code>100</code>&nbsp;之间。</li>
<li>二叉树包含的节点数目在&nbsp;<code>1</code>&nbsp;&nbsp;<code>2500</code>&nbsp;之间。</li>
</ul>
<p>给你一个 m x n 的网格图&nbsp;<code>grid</code>&nbsp;&nbsp;<code>grid</code>&nbsp;中每个格子都有一个数字,对应着从该格子出发下一步走的方向。&nbsp;<code>grid[i][j]</code>&nbsp;中的数字可能为以下几种情况:</p>
<ul>
<li><strong>1</strong>&nbsp;,下一步往右走,也就是你会从 <code>grid[i][j]</code>&nbsp;走到 <code>grid[i][j + 1]</code></li>
<li><strong>2</strong>&nbsp;,下一步往左走,也就是你会从 <code>grid[i][j]</code>&nbsp;走到 <code>grid[i][j - 1]</code></li>
<li><strong>3</strong>&nbsp;,下一步往下走,也就是你会从 <code>grid[i][j]</code>&nbsp;走到 <code>grid[i + 1][j]</code></li>
<li><strong>4</strong>&nbsp;,下一步往上走,也就是你会从 <code>grid[i][j]</code>&nbsp;走到 <code>grid[i - 1][j]</code></li>
</ul>
<p>注意网格图中可能会有&nbsp;<strong>无效数字</strong>&nbsp;,因为它们可能指向&nbsp;<code>grid</code>&nbsp;以外的区域。</p>
<p>一开始,你会从最左上角的格子&nbsp;<code>(0,0)</code>&nbsp;出发。我们定义一条&nbsp;<strong>有效路径</strong>&nbsp;为从格子&nbsp;<code>(0,0)</code>&nbsp;出发,每一步都顺着数字对应方向走,最终在最右下角的格子&nbsp;<code>(m - 1, n - 1)</code>&nbsp;结束的路径。有效路径&nbsp;<strong>不需要是最短路径</strong>&nbsp;</p>
<p>你可以花费&nbsp;<code>cost = 1</code>&nbsp;的代价修改一个格子中的数字,但每个格子中的数字&nbsp;<strong>只能修改一次</strong>&nbsp;</p>
<p>请你返回让网格图至少有一条有效路径的最小代价。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/29/grid1.png" style="height: 528px; width: 542px;"></p>
<pre><strong>输入:</strong>grid = [[1,1,1,1],[2,2,2,2],[1,1,1,1],[2,2,2,2]]
<strong>输出:</strong>3
<strong>解释:</strong>你将从点 (0, 0) 出发。
到达 (3, 3) 的路径为: (0, 0) --&gt; (0, 1) --&gt; (0, 2) --&gt; (0, 3) 花费代价 cost = 1 使方向向下 --&gt; (1, 3) --&gt; (1, 2) --&gt; (1, 1) --&gt; (1, 0) 花费代价 cost = 1 使方向向下 --&gt; (2, 0) --&gt; (2, 1) --&gt; (2, 2) --&gt; (2, 3) 花费代价 cost = 1 使方向向下 --&gt; (3, 3)
总花费为 cost = 3.
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/29/grid2.png" style="height: 408px; width: 419px;"></p>
<pre><strong>输入:</strong>grid = [[1,1,3],[3,2,2],[1,1,4]]
<strong>输出:</strong>0
<strong>解释:</strong>不修改任何数字你就可以从 (0, 0) 到达 (2, 2) 。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/29/grid3.png" style="height: 302px; width: 314px;"></p>
<pre><strong>输入:</strong>grid = [[1,2],[4,3]]
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>grid = [[2,2,2],[2,2,2]]
<strong>输出:</strong>3
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>grid = [[4]]
<strong>输出:</strong>0
</pre>
<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;= 100</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>&nbsp;,请你根据下面的算法重新构造字符串:</p>
<ol>
<li><code>s</code>&nbsp;中选出 <strong>最小</strong>&nbsp;的字符,将它 <strong>接在</strong>&nbsp;结果字符串的后面。</li>
<li><code>s</code>&nbsp;剩余字符中选出&nbsp;<strong>最小</strong>&nbsp;的字符,且该字符比上一个添加的字符大,将它 <strong>接在</strong>&nbsp;结果字符串后面。</li>
<li>重复步骤 2 ,直到你没法从 <code>s</code>&nbsp;中选择字符。</li>
<li><code>s</code>&nbsp;中选出 <strong>最大</strong>&nbsp;的字符,将它 <strong>接在</strong>&nbsp;结果字符串的后面。</li>
<li><code>s</code>&nbsp;剩余字符中选出&nbsp;<strong>最大</strong>&nbsp;的字符,且该字符比上一个添加的字符小,将它 <strong>接在</strong>&nbsp;结果字符串后面。</li>
<li>重复步骤 5&nbsp;,直到你没法从 <code>s</code>&nbsp;中选择字符。</li>
<li>重复步骤 1 到 6 ,直到 <code>s</code>&nbsp;中所有字符都已经被选过。</li>
</ol>
<p>在任何一步中,如果最小或者最大字符不止一个&nbsp;,你可以选择其中任意一个,并将其添加到结果字符串。</p>
<p>请你返回将&nbsp;<code>s</code>&nbsp;中字符重新排序后的 <strong>结果字符串</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaaabbbbcccc&quot;
<strong>输出:</strong>&quot;abccbaabccba&quot;
<strong>解释:</strong>第一轮的步骤 1,2,3 后,结果字符串为 result = &quot;abc&quot;
第一轮的步骤 4,5,6 后,结果字符串为 result = &quot;abccba&quot;
第一轮结束,现在 s = &quot;aabbcc&quot; ,我们再次回到步骤 1
第二轮的步骤 1,2,3 后,结果字符串为 result = &quot;abccbaabc&quot;
第二轮的步骤 4,5,6 后,结果字符串为 result = &quot;abccbaabccba&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;rat&quot;
<strong>输出:</strong>&quot;art&quot;
<strong>解释:</strong>单词 &quot;rat&quot; 在上述算法重排序以后变成 &quot;art&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;leetcode&quot;
<strong>输出:</strong>&quot;cdelotee&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;ggggggg&quot;
<strong>输出:</strong>&quot;ggggggg&quot;
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>s = &quot;spo&quot;
<strong>输出:</strong>&quot;ops&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 500</code></li>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
</ul>
<p>给你一个整数数组 <code>nums</code> ,除某个元素仅出现 <strong>一次</strong> 外,其余每个元素都恰出现 <strong>三次 。</strong>请你找出并返回那个只出现了一次的元素。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [2,2,3,2]
<strong>输出:</strong>3
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [0,1,0,1,0,1,99]
<strong>输出:</strong>99
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>
<li><code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code></li>
<li><code>nums</code> 中,除某个元素仅出现 <strong>一次</strong> 外,其余每个元素都恰出现 <strong>三次</strong></li>
</ul>
<p> </p>
<p><strong>进阶:</strong>你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?</p>
<p>给你一个字符串&nbsp;<code>s</code>&nbsp;,请你返回满足以下条件的最长子字符串的长度:每个元音字母,即&nbsp;&#39;a&#39;&#39;e&#39;&#39;i&#39;&#39;o&#39;&#39;u&#39; ,在子字符串中都恰好出现了偶数次。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;eleetminicoworoep&quot;
<strong>输出:</strong>13
<strong>解释:</strong>最长子字符串是 &quot;leetminicowor&quot; ,它包含 <strong>e,i,o</strong>&nbsp;各 2 个,以及 0 个 <strong>a</strong><strong>u </strong>
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;leetcodeisgreat&quot;
<strong>输出:</strong>5
<strong>解释:</strong>最长子字符串是 &quot;leetc&quot; ,其中包含 2 个 <strong>e</strong>
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;bcbcbc&quot;
<strong>输出:</strong>6
<strong>解释:</strong>这个示例中,字符串 &quot;bcbcbc&quot; 本身就是最长的,因为所有的元音 <strong>a,</strong><strong>e,</strong><strong>i,</strong><strong>o,</strong><strong>u</strong> 都出现了 0 次。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 5 x 10^5</code></li>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
</ul>
<p>给你一棵以&nbsp;<code>root</code>&nbsp;为根的二叉树,二叉树中的交错路径定义如下:</p>
<ul>
<li>选择二叉树中 <strong>任意</strong>&nbsp;节点和一个方向(左或者右)。</li>
<li>如果前进方向为右,那么移动到当前节点的的右子节点,否则移动到它的左子节点。</li>
<li>改变前进方向:左变右或者右变左。</li>
<li>重复第二步和第三步,直到你在树中无法继续移动。</li>
</ul>
<p>交错路径的长度定义为:<strong>访问过的节点数目 - 1</strong>(单个节点的路径长度为 0 )。</p>
<p>请你返回给定树中最长 <strong>交错路径</strong>&nbsp;的长度。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/07/sample_1_1702.png" style="height: 283px; width: 151px;"></strong></p>
<pre><strong>输入:</strong>root = [1,null,1,1,1,null,null,1,1,null,1,null,null,null,1,null,1]
<strong>输出:</strong>3
<strong>解释:</strong>蓝色节点为树中最长交错路径(右 -&gt; 左 -&gt; 右)。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/07/sample_2_1702.png" style="height: 253px; width: 120px;"></strong></p>
<pre><strong>输入:</strong>root = [1,1,1,null,1,null,null,1,1,null,1]
<strong>输出:</strong>4
<strong>解释:</strong>蓝色节点为树中最长交错路径(左 -&gt; 右 -&gt; 左 -&gt; 右)。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>root = [1]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>每棵树最多有&nbsp;<code>50000</code>&nbsp;个节点。</li>
<li>每个节点的值在&nbsp;<code>[1, 100]</code> 之间。</li>
</ul>
<p>给你一棵以 <code>root</code> 为根的 <strong>二叉树</strong> ,请你返回 <strong>任意</strong> 二叉搜索子树的最大键值和。</p>
<p>二叉搜索树的定义如下:</p>
<ul>
<li>任意节点的左子树中的键值都 <strong>小于</strong> 此节点的键值。</li>
<li>任意节点的右子树中的键值都 <strong>大于</strong> 此节点的键值。</li>
<li>任意节点的左子树和右子树都是二叉搜索树。</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/07/sample_1_1709.png" style="height: 250px; width: 320px;" /></p>
<pre>
<strong>输入:</strong>root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]
<strong>输出:</strong>20
<strong>解释:</strong>键值为 3 的子树是和最大的二叉搜索树。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/07/sample_2_1709.png" style="height: 180px; width: 134px;" /></p>
<pre>
<strong>输入:</strong>root = [4,3,null,1,2]
<strong>输出:</strong>2
<strong>解释:</strong>键值为 2 的单节点子树是和最大的二叉搜索树。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [-4,-2,-5]
<strong>输出:</strong>0
<strong>解释:</strong>所有节点键值都为负数,和最大的二叉搜索树为空。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>root = [2,1,3]
<strong>输出:</strong>6
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>root = [5,4,8,3,null,6,3]
<strong>输出:</strong>7
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>每棵树有 <code>1</code><code>40000</code> 个节点。</li>
<li>每个节点的键值在 <code>[-4 * 10^4 , 4 * 10^4]</code> 之间。</li>
</ul>
<p>给你一个整数 <code>n</code>,请你返回一个含<em> <code>n</code> </em>个字符的字符串,其中每种字符在该字符串中都恰好出现 <strong>奇数次</strong> <em><strong></strong></em></p>
<p>返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串,则返回其中任意一个即可。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 4
<strong>输出:</strong>&quot;pppz&quot;
<strong>解释:</strong>&quot;pppz&quot; 是一个满足题目要求的字符串,因为 &#39;p&#39; 出现 3 次,且 &#39;z&#39; 出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:&quot;ohhh&quot;&quot;love&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>&quot;xy&quot;
<strong>解释:</strong>&quot;xy&quot; 是一个满足题目要求的字符串,因为 &#39;x&#39;&#39;y&#39; 各出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:&quot;ag&quot;&quot;ur&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 7
<strong>输出:</strong>&quot;holasss&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 500</code></li>
</ul>
<p>房间中有 <code>n</code> 枚灯泡,编号从 <code>1</code><code>n</code>,自左向右排成一排。最初,所有的灯都是关着的。</p>
<p><em>k</em>&nbsp; 时刻( <em>k</em> 的取值范围是 <code>0</code><code>n - 1</code>),我们打开 <code>light[k]</code> 这个灯。</p>
<p>灯的颜色要想 <strong>变成蓝色</strong> 就必须同时满足下面两个条件:</p>
<ul>
<li>灯处于打开状态。</li>
<li>排在它之前(左侧)的所有灯也都处于打开状态。</li>
</ul>
<p>请返回能够让 <strong>所有开着的</strong> 灯都 <strong>变成蓝色</strong> 的时刻 <strong>数目 。</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/08/sample_2_1725.png" style="height: 254px; width: 575px;"></p>
<pre><strong>输入:</strong>light = [2,1,3,5,4]
<strong>输出:</strong>3
<strong>解释:</strong>所有开着的灯都变蓝的时刻分别是 1,2 和 4 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>light = [3,2,4,1,5]
<strong>输出:</strong>2
<strong>解释:</strong>所有开着的灯都变蓝的时刻分别是 3 和 4(index-0)。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>light = [4,1,2,3]
<strong>输出:</strong>1
<strong>解释:</strong>所有开着的灯都变蓝的时刻是 3(index-0)。
第 4 个灯在时刻 3 变蓝。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>light = [2,1,4,3,6,5]
<strong>输出:</strong>3
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>light = [1,2,3,4,5,6]
<strong>输出:</strong>6
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n ==&nbsp;light.length</code></li>
<li><code>1 &lt;= n &lt;= 5 * 10^4</code></li>
<li><code>light</code><code>[1, 2, ..., n]</code> 的一个排列。</li>
</ul>
<p>公司里有 <code>n</code> 名员工,每个员工的 ID 都是独一无二的,编号从 <code>0</code><code>n - 1</code>。公司的总负责人通过 <code>headID</code> 进行标识。</p>
<p><code>manager</code> 数组中,每个员工都有一个直属负责人,其中 <code>manager[i]</code> 是第 <code>i</code> 名员工的直属负责人。对于总负责人,<code>manager[headID] = -1</code>。题目保证从属关系可以用树结构显示。</p>
<p>公司总负责人想要向公司所有员工通告一条紧急消息。他将会首先通知他的直属下属们,然后由这些下属通知他们的下属,直到所有的员工都得知这条紧急消息。</p>
<p><code>i</code> 名员工需要 <code>informTime[i]</code> 分钟来通知它的所有直属下属(也就是说在 <code>informTime[i]</code> 分钟后,他的所有直属下属都可以开始传播这一消息)。</p>
<p>返回通知所有员工这一紧急消息所需要的 <strong>分钟数</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 1, headID = 0, manager = [-1], informTime = [0]
<strong>输出:</strong>0
<strong>解释:</strong>公司总负责人是该公司的唯一一名员工。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/08/graph.png" style="height: 174px; width: 404px;"></p>
<pre><strong>输入:</strong>n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]
<strong>输出:</strong>1
<strong>解释:</strong>id = 2 的员工是公司的总负责人,也是其他所有员工的直属负责人,他需要 1 分钟来通知所有员工。
上图显示了公司员工的树结构。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/08/1730_example_3_5.PNG" style="height: 432px; width: 568px;"></p>
<pre><strong>输入:</strong>n = 7, headID = 6, manager = [1,2,3,4,5,6,-1], informTime = [0,6,5,4,3,2,1]
<strong>输出:</strong>21
<strong>解释:</strong>总负责人 id = 6。他将在 1 分钟内通知 id = 5 的员工。
id = 5 的员工将在 2 分钟内通知 id = 4 的员工。
id = 4 的员工将在 3 分钟内通知 id = 3 的员工。
id = 3 的员工将在 4 分钟内通知 id = 2 的员工。
id = 2 的员工将在 5 分钟内通知 id = 1 的员工。
id = 1 的员工将在 6 分钟内通知 id = 0 的员工。
所需时间 = 1 + 2 + 3 + 4 + 5 + 6 = 21 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 15, headID = 0, manager = [-1,0,0,1,1,2,2,3,3,4,4,5,5,6,6], informTime = [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0]
<strong>输出:</strong>3
<strong>解释:</strong>第一分钟总负责人通知员工 1 和 2 。
第二分钟他们将会通知员工 3, 4, 5 和 6 。
第三分钟他们将会通知剩下的员工。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 4, headID = 2, manager = [3,3,-1,2], informTime = [0,0,162,914]
<strong>输出:</strong>1076
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li><code>0 &lt;= headID &lt; n</code></li>
<li><code>manager.length == n</code></li>
<li><code>0 &lt;= manager[i] &lt; n</code></li>
<li><code>manager[headID] == -1</code></li>
<li><code>informTime.length&nbsp;== n</code></li>
<li><code>0 &lt;= informTime[i] &lt;= 1000</code></li>
<li>如果员工 <code>i</code> 没有下属,<code>informTime[i] == 0</code></li>
<li>题目 <strong>保证</strong> 所有员工都可以收到通知。</li>
</ul>
<p>给你一棵由 n 个顶点组成的无向树,顶点编号从 1 到 <code>n</code>。青蛙从 <strong>顶点 1</strong> 开始起跳。规则如下:</p>
<ul>
<li>在一秒内,青蛙从它所在的当前顶点跳到另一个 <strong>未访问</strong> 过的顶点(如果它们直接相连)。</li>
<li>青蛙无法跳回已经访问过的顶点。</li>
<li>如果青蛙可以跳到多个不同顶点,那么它跳到其中任意一个顶点上的机率都相同。</li>
<li>如果青蛙不能跳到任何未访问过的顶点上,那么它每次跳跃都会停留在原地。</li>
</ul>
<p>无向树的边用数组 <code>edges</code> 描述,其中 <code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>]</code> 意味着存在一条直接连通 <code>from<sub>i</sub></code><code>to<sub>i</sub></code> 两个顶点的边。</p>
<p>返回青蛙在 <em><code>t</code></em> 秒后位于目标顶点 <em><code>target</code> </em>上的概率。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/08/frog_2.png" style="height: 236px; width: 350px;"></p>
<pre><strong>输入:</strong>n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 2, target = 4
<strong>输出:</strong>0.16666666666666666
<strong>解释:</strong>上图显示了青蛙的跳跃路径。青蛙从顶点 1 起跳,第 <strong>1 秒</strong> 有 1/3 的概率跳到顶点 2 ,然后第 <strong>2 秒</strong> 有 1/2 的概率跳到顶点 4,因此青蛙在 2 秒后位于顶点 4 的概率是 1/3 * 1/2 = 1/6 = 0.16666666666666666 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/08/frog_3.png" style="height: 236px; width: 350px;"></strong></p>
<pre><strong>输入:</strong>n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 1, target = 7
<strong>输出:</strong>0.3333333333333333
<strong>解释:</strong>上图显示了青蛙的跳跃路径。青蛙从顶点 1 起跳,有 1/3 = 0.3333333333333333 的概率能够 <strong>1 秒</strong> 后跳到顶点 7 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 20, target = 6
<strong>输出:</strong>0.16666666666666666
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 100</code></li>
<li><code>edges.length == n-1</code></li>
<li><code>edges[i].length == 2</code></li>
<li><code>1 &lt;= edges[i][0], edges[i][1] &lt;= n</code></li>
<li><code>1 &lt;= t&nbsp;&lt;= 50</code></li>
<li><code>1 &lt;= target&nbsp;&lt;= n</code></li>
<li>与准确值误差在 <code>10^-5</code> 之内的结果将被判定为正确。</li>
</ul>
<p>给你两棵二叉树,原始树 <code>original</code> 和克隆树 <code>cloned</code>,以及一个位于原始树 <code>original</code>&nbsp;中的目标节点&nbsp;<code>target</code></p>
<p>其中,克隆树 <code>cloned</code>&nbsp;是原始树 <code>original</code>&nbsp;的一个<strong> 副本 </strong></p>
<p>请找出在树&nbsp;<code>cloned</code>&nbsp;中,与&nbsp;<code>target</code>&nbsp;<strong>相同&nbsp;</strong>的节点,并返回对该节点的引用(在 C/C++ 等有指针的语言中返回 节点指针,其他语言返回节点本身)。</p>
<p>&nbsp;</p>
<p><strong>注意:</strong></p>
<ol>
<li><strong>不能</strong> 对两棵二叉树,以及 <code>target</code>&nbsp;节点进行更改。</li>
<li><strong>只能</strong> 返回对克隆树&nbsp;<code>cloned</code>&nbsp;中已有的节点的引用。</li>
</ol>
<ul>
</ul>
<p><strong>进阶:</strong>如果树中允许出现值相同的节点,你将如何解答?</p>
<p>&nbsp;</p>
<ul>
</ul>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e1.png" style="height: 426px; width: 544px;"></p>
<pre><strong>输入:</strong> tree = [7,4,3,null,null,6,19], target = 3
<strong>输出:</strong> 3
<strong>解释:</strong> 上图画出了树 original 和 cloned。target 节点在树 original 中,用绿色标记。答案是树 cloned 中的黄颜色的节点(其他示例类似)。</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e2.png" style="height: 159px; width: 221px;"></p>
<pre><strong>输入:</strong> tree = [7], target = 7
<strong>输出:</strong> 7
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e3.png" style="height: 486px; width: 459px;"></p>
<pre><strong>输入:</strong> tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4
<strong>输出:</strong> 4
</pre>
<p><strong>示例 4:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e4.png" style="height: 239px; width: 555px;"></p>
<pre><strong>输入:</strong> tree = [1,2,3,4,5,6,7,8,9,10], target = 5
<strong>输出:</strong> 5
</pre>
<p><strong>示例 5:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e5.png" style="height: 345px; width: 427px;"></p>
<pre><strong>输入:</strong> tree = [1,2,null,3], target = 2
<strong>输出:</strong> 2</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点的数量范围为&nbsp;<code>[1, 10^4]</code>&nbsp;</li>
<li>同一棵树中,没有值相同的节点。</li>
<li><code>target</code>&nbsp;节点是树&nbsp;<code>original</code>&nbsp;中的一个节点,并且不会是&nbsp;<code>null</code>&nbsp;</li>
</ul>
<p>给你一个 <code>m * n</code> 的矩阵,矩阵中的数字 <strong>各不相同</strong> 。请你按 <strong>任意</strong> 顺序返回矩阵中的所有幸运数。</p>
<p>幸运数是指矩阵中满足同时下列两个条件的元素:</p>
<ul>
<li>在同一行的所有元素中最小</li>
<li>在同一列的所有元素中最大</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>matrix = [[3,7,8],[9,11,13],[15,16,17]]
<strong>输出:</strong>[15]
<strong>解释:</strong>15 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]
<strong>输出:</strong>[12]
<strong>解释:</strong>12 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>matrix = [[7,8],[1,2]]
<strong>输出:</strong>[7]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == mat.length</code></li>
<li><code>n == mat[i].length</code></li>
<li><code>1 &lt;= n, m &lt;= 50</code></li>
<li><code>1 &lt;=&nbsp;matrix[i][j]&nbsp;&lt;= 10^5</code></li>
<li>矩阵中的所有元素都是不同的</li>
</ul>
<p>给你一个长度为 <code>n</code> 的链表,每个节点包含一个额外增加的随机指针 <code>random</code> ,该指针可以指向链表中的任何节点或空节点。</p>
<p>构造这个链表的 <strong><a href="https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin" target="_blank">深拷贝</a></strong>。 深拷贝应该正好由 <code>n</code><strong>全新</strong> 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 <code>next</code> 指针和 <code>random</code> 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。<strong>复制链表中的指针都不应指向原链表中的节点 </strong></p>
<p>例如,如果原链表中有 <code>X</code><code>Y</code> 两个节点,其中 <code>X.random --> Y</code> 。那么在复制链表中对应的两个节点 <code>x</code><code>y</code> ,同样有 <code>x.random --> y</code></p>
<p>返回复制链表的头节点。</p>
<p>用一个由 <code>n</code> 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 <code>[val, random_index]</code> 表示:</p>
<ul>
<li><code>val</code>:一个表示 <code>Node.val</code> 的整数。</li>
<li><code>random_index</code>:随机指针指向的节点索引(范围从 <code>0</code> 到 <code>n-1</code>);如果不指向任何节点,则为  <code>null</code> 。</li>
</ul>
<p>你的代码 <strong></strong> 接受原链表的头节点 <code>head</code> 作为传入参数。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/09/e1.png" style="height: 138px; width: 680px;" /></p>
<pre>
<strong>输入:</strong>head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
<strong>输出:</strong>[[7,null],[13,0],[11,4],[10,2],[1,0]]
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/09/e2.png" style="height: 111px; width: 680px;" /></p>
<pre>
<strong>输入:</strong>head = [[1,1],[2,1]]
<strong>输出:</strong>[[1,1],[2,1]]
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/09/e3.png" style="height: 119px; width: 680px;" /></strong></p>
<pre>
<strong>输入:</strong>head = [[3,null],[3,0],[3,null]]
<strong>输出:</strong>[[3,null],[3,0],[3,null]]
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>head = []
<strong>输出:</strong>[]
<strong>解释:</strong>给定的链表为空(空指针),因此返回 null。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 <= n <= 1000</code></li>
<li><code>-10000 <= Node.val <= 10000</code></li>
<li><code>Node.random</code> 为空(null)或指向链表中的节点。</li>
</ul>
<p>请你设计一个支持下述操作的栈。</p>
<p>实现自定义栈类 <code>CustomStack</code></p>
<ul>
<li><code>CustomStack(int maxSize)</code>:用 <code>maxSize</code> 初始化对象,<code>maxSize</code> 是栈中最多能容纳的元素数量,栈在增长到 <code>maxSize</code> 之后则不支持 <code>push</code> 操作。</li>
<li><code>void push(int x)</code>:如果栈还未增长到 <code>maxSize</code> ,就将 <code>x</code> 添加到栈顶。</li>
<li><code>int pop()</code>:弹出栈顶元素,并返回栈顶的值,或栈为空时返回 <strong>-1</strong></li>
<li><code>void inc(int k, int val)</code>:栈底的 <code>k</code> 个元素的值都增加 <code>val</code> 。如果栈中元素总数小于 <code>k</code> ,则栈中的所有元素都增加 <code>val</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>
[&quot;CustomStack&quot;,&quot;push&quot;,&quot;push&quot;,&quot;pop&quot;,&quot;push&quot;,&quot;push&quot;,&quot;push&quot;,&quot;increment&quot;,&quot;increment&quot;,&quot;pop&quot;,&quot;pop&quot;,&quot;pop&quot;,&quot;pop&quot;]
[[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
<strong>输出:</strong>
[null,null,null,2,null,null,null,null,null,103,202,201,-1]
<strong>解释:</strong>
CustomStack customStack = new CustomStack(3); // 栈是空的 []
customStack.push(1); // 栈变为 [1]
customStack.push(2); // 栈变为 [1, 2]
customStack.pop(); // 返回 2 --&gt; 返回栈顶值 2,栈变为 [1]
customStack.push(2); // 栈变为 [1, 2]
customStack.push(3); // 栈变为 [1, 2, 3]
customStack.push(4); // 栈仍然是 [1, 2, 3],不能添加其他元素使栈大小变为 4
customStack.increment(5, 100); // 栈变为 [101, 102, 103]
customStack.increment(2, 100); // 栈变为 [201, 202, 103]
customStack.pop(); // 返回 103 --&gt; 返回栈顶值 103,栈变为 [201, 202]
customStack.pop(); // 返回 202 --&gt; 返回栈顶值 202,栈变为 [201]
customStack.pop(); // 返回 201 --&gt; 返回栈顶值 201,栈变为 []
customStack.pop(); // 返回 -1 --&gt; 栈为空,返回 -1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= maxSize &lt;= 1000</code></li>
<li><code>1 &lt;= x &lt;= 1000</code></li>
<li><code>1 &lt;= k &lt;= 1000</code></li>
<li><code>0 &lt;= val &lt;= 100</code></li>
<li>每种方法 <code>increment</code><code>push</code> 以及 <code>pop</code> 分别最多调用 <code>1000</code></li>
</ul>
<p>给你一棵二叉搜索树,请你返回一棵&nbsp;<strong>平衡后</strong>&nbsp;的二叉搜索树,新生成的树应该与原来的树有着相同的节点值。</p>
<p>如果一棵二叉搜索树中,每个节点的两棵子树高度差不超过 1 ,我们就称这棵二叉搜索树是&nbsp;<strong>平衡的</strong></p>
<p>如果有多种构造方法,请你返回任意一种。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/15/1515_ex1.png" style="height: 248px; width: 250px;"><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/15/1515_ex1_out.png" style="height: 200px; width: 200px;"></strong></p>
<pre><strong>输入:</strong>root = [1,null,2,null,3,null,4,null,null]
<strong>输出:</strong>[2,1,3,null,null,null,4]
<strong>解释:</strong>这不是唯一的正确答案,[3,1,4,null,2,null,null] 也是一个可行的构造方案。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>树节点的数目在&nbsp;<code>1</code>&nbsp;&nbsp;<code>10^4</code>&nbsp;之间。</li>
<li>树节点的值互不相同,且在&nbsp;<code>1</code>&nbsp;&nbsp;<code>10^5</code> 之间。</li>
</ul>
<p>给你两个整数数组&nbsp;<code>arr1</code>&nbsp;&nbsp;<code>arr2</code>&nbsp;和一个整数&nbsp;<code>d</code>&nbsp;,请你返回两个数组之间的&nbsp;<strong>距离值</strong>&nbsp;</p>
<p><strong>距离值</strong><strong>&nbsp;</strong>定义为符合此距离要求的元素数目:对于元素&nbsp;<code>arr1[i]</code>&nbsp;,不存在任何元素&nbsp;<code>arr2[j]</code>&nbsp;满足 <code>|arr1[i]-arr2[j]| &lt;= d</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
<strong>输出:</strong>2
<strong>解释:</strong>
对于 arr1[0]=4 我们有:
|4-10|=6 &gt; d=2
|4-9|=5 &gt; d=2
|4-1|=3 &gt; d=2
|4-8|=4 &gt; d=2
所以 arr1[0]=4 符合距离要求
对于 arr1[1]=5 我们有:
|5-10|=5 &gt; d=2
|5-9|=4 &gt; d=2
|5-1|=4 &gt; d=2
|5-8|=3 &gt; d=2
所以 arr1[1]=5 也符合距离要求
对于 arr1[2]=8 我们有:
<strong>|8-10|=2 &lt;= d=2</strong>
<strong>|8-9|=1 &lt;= d=2</strong>
|8-1|=7 &gt; d=2
<strong>|8-8|=0 &lt;= d=2</strong>
存在距离小于等于 2 的情况,不符合距离要求
故而只有 arr1[0]=4 和 arr1[1]=5 两个符合距离要求,距离值为 2</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
<strong>输出:</strong>2
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr1.length, arr2.length &lt;= 500</code></li>
<li><code>-10^3 &lt;= arr1[i], arr2[j] &lt;= 10^3</code></li>
<li><code>0 &lt;= d &lt;= 100</code></li>
</ul>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/cinema_seats_1.png" style="height: 149px; width: 400px;"></p>
<p>如上图所示,电影院的观影厅中有 <code>n</code>&nbsp;行座位,行编号从 1&nbsp;<code>n</code>&nbsp;,且每一行内总共有 10 个座位,列编号从 1 到 10 。</p>
<p>给你数组&nbsp;<code>reservedSeats</code>&nbsp;,包含所有已经被预约了的座位。比如说,<code>researvedSeats[i]=[3,8]</code>&nbsp;,它表示第&nbsp;<strong>3</strong>&nbsp;行第&nbsp;<strong>8</strong>&nbsp;个座位被预约了。</p>
<p>请你返回&nbsp;<strong>最多能安排多少个 4 人家庭</strong>&nbsp;。4 人家庭要占据&nbsp;<strong>同一行内连续&nbsp;</strong>的 4 个座位。隔着过道的座位(比方说 [3,3] 和 [3,4])不是连续的座位,但是如果你可以将 4 人家庭拆成过道两边各坐 2 人,这样子是允许的。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/cinema_seats_3.png" style="height: 96px; width: 400px;"></p>
<pre><strong>输入:</strong>n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]
<strong>输出:</strong>4
<strong>解释:</strong>上图所示是最优的安排方案,总共可以安排 4 个家庭。蓝色的叉表示被预约的座位,橙色的连续座位表示一个 4 人家庭。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2, reservedSeats = [[2,1],[1,8],[2,6]]
<strong>输出:</strong>2
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^9</code></li>
<li><code>1 &lt;=&nbsp;reservedSeats.length &lt;= min(10*n, 10^4)</code></li>
<li><code>reservedSeats[i].length == 2</code></li>
<li><code>1&nbsp;&lt;=&nbsp;reservedSeats[i][0] &lt;= n</code></li>
<li><code>1 &lt;=&nbsp;reservedSeats[i][1] &lt;= 10</code></li>
<li>所有&nbsp;<code>reservedSeats[i]</code> 都是互不相同的。</li>
</ul>
<p>我们将整数 <code>x</code>&nbsp;<strong>权重</strong> 定义为按照下述规则将 <code>x</code>&nbsp;变成 <code>1</code>&nbsp;所需要的步数:</p>
<ul>
<li>如果&nbsp;<code>x</code>&nbsp;是偶数,那么&nbsp;<code>x = x / 2</code></li>
<li>如果&nbsp;<code>x</code>&nbsp;是奇数,那么&nbsp;<code>x = 3 * x + 1</code></li>
</ul>
<p>比方说,x=3 的权重为 7 。因为 3 需要 7 步变成 1 (3 --&gt; 10 --&gt; 5 --&gt; 16 --&gt; 8 --&gt; 4 --&gt; 2 --&gt; 1)。</p>
<p>给你三个整数&nbsp;<code>lo</code>&nbsp;<code>hi</code>&nbsp;<code>k</code>&nbsp;。你的任务是将区间&nbsp;<code>[lo, hi]</code>&nbsp;之间的整数按照它们的权重&nbsp;<strong>升序排序&nbsp;</strong>,如果大于等于 2 个整数有&nbsp;<strong>相同</strong>&nbsp;的权重,那么按照数字自身的数值&nbsp;<strong>升序排序</strong>&nbsp;</p>
<p>请你返回区间&nbsp;<code>[lo, hi]</code>&nbsp;之间的整数按权重排序后的第&nbsp;<code>k</code>&nbsp;个数。</p>
<p>注意,题目保证对于任意整数&nbsp;<code>x</code>&nbsp;<code>(lo &lt;= x &lt;= hi)</code>&nbsp;,它变成&nbsp;<code>1</code> 所需要的步数是一个 32 位有符号整数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>lo = 12, hi = 15, k = 2
<strong>输出:</strong>13
<strong>解释:</strong>12 的权重为 9(12 --&gt; 6 --&gt; 3 --&gt; 10 --&gt; 5 --&gt; 16 --&gt; 8 --&gt; 4 --&gt; 2 --&gt; 1)
13 的权重为 9
14 的权重为 17
15 的权重为 17
区间内的数按权重排序以后的结果为 [12,13,14,15] 。对于 k = 2 ,答案是第二个整数也就是 13 。
注意,12 和 13 有相同的权重,所以我们按照它们本身升序排序。14 和 15 同理。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>lo = 1, hi = 1, k = 1
<strong>输出:</strong>1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>lo = 7, hi = 11, k = 4
<strong>输出:</strong>7
<strong>解释:</strong>区间内整数 [7, 8, 9, 10, 11] 对应的权重为 [16, 3, 19, 6, 14] 。
按权重排序后得到的结果为 [8, 10, 11, 7, 9] 。
排序后数组中第 4 个数字为 7 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>lo = 10, hi = 20, k = 5
<strong>输出:</strong>13
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>lo = 1, hi = 1000, k = 777
<strong>输出:</strong>570
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= lo &lt;= hi &lt;= 1000</code></li>
<li><code>1 &lt;= k &lt;= hi - lo + 1</code></li>
</ul>
<p>给你一个披萨,它由 3n 块不同大小的部分组成,现在你和你的朋友们需要按照如下规则来分披萨:</p>
<ul>
<li>你挑选 <strong>任意</strong>&nbsp;一块披萨。</li>
<li>Alice 将会挑选你所选择的披萨逆时针方向的下一块披萨。</li>
<li>Bob 将会挑选你所选择的披萨顺时针方向的下一块披萨。</li>
<li>重复上述过程直到没有披萨剩下。</li>
</ul>
<p>每一块披萨的大小按顺时针方向由循环数组 <code>slices</code>&nbsp;表示。</p>
<p>请你返回你可以获得的披萨大小总和的最大值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/sample_3_1723.png" style="height: 240px; width: 475px;"></p>
<pre><strong>输入:</strong>slices = [1,2,3,4,5,6]
<strong>输出:</strong>10
<strong>解释:</strong>选择大小为 4 的披萨,Alice 和 Bob 分别挑选大小为 3 和 5 的披萨。然后你选择大小为 6 的披萨,Alice 和 Bob 分别挑选大小为 2 和 1 的披萨。你获得的披萨总大小为 4 + 6 = 10 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/sample_4_1723.png" style="height: 250px; width: 475px;"></strong></p>
<pre><strong>输入:</strong>slices = [8,9,8,6,1,1]
<strong>输出:</strong>16
<strong>解释:</strong>两轮都选大小为 8 的披萨。如果你选择大小为 9 的披萨,你的朋友们就会选择大小为 8 的披萨,这种情况下你的总和不是最大的。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>slices = [4,1,2,5,8,3,1,9,7]
<strong>输出:</strong>21
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>slices = [3,1,2]
<strong>输出:</strong>3
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= slices.length &lt;= 500</code></li>
<li><code>slices.length % 3 == 0</code></li>
<li><code>1 &lt;= slices[i] &lt;= 1000</code></li>
</ul>
<p>给你两个整数数组 <code>nums</code><code>index</code>。你需要按照以下规则创建目标数组:</p>
<ul>
<li>目标数组 <code>target</code> 最初为空。</li>
<li>按从左到右的顺序依次读取 <code>nums[i]</code><code>index[i]</code>,在 <code>target</code> 数组中的下标 <code>index[i]</code> 处插入值 <code>nums[i]</code></li>
<li>重复上一步,直到在 <code>nums</code><code>index</code> 中都没有要读取的元素。</li>
</ul>
<p>请你返回目标数组。</p>
<p>题目保证数字插入位置总是存在。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [0,1,2,3,4], index = [0,1,2,2,1]
<strong>输出:</strong>[0,4,1,3,2]
<strong>解释:</strong>
nums index target
0 0 [0]
1 1 [0,1]
2 2 [0,1,2]
3 2 [0,1,3,2]
4 1 [0,4,1,3,2]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3,4,0], index = [0,1,2,3,0]
<strong>输出:</strong>[0,1,2,3,4]
<strong>解释:</strong>
nums index target
1 0 [1]
2 1 [1,2]
3 2 [1,2,3]
4 3 [1,2,3,4]
0 0 [0,1,2,3,4]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1], index = [0]
<strong>输出:</strong>[1]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length, index.length &lt;= 100</code></li>
<li><code>nums.length == index.length</code></li>
<li><code>0 &lt;= nums[i] &lt;= 100</code></li>
<li><code>0 &lt;= index[i] &lt;= i</code></li>
</ul>
<p>给你一个整数数组 <code>nums</code>,请你返回该数组中恰有四个因数的这些整数的各因数之和。</p>
<p>如果数组中不存在满足题意的整数,则返回 <code>0</code></p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>nums = [21,4,7]
<strong>输出:</strong>32
<strong>解释:</strong>
21 有 4 个因数:1, 3, 7, 21
4 有 3 个因数:1, 2, 4
7 有 2 个因数:1, 7
答案仅为 21 的所有因数的和。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^4</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^5</code></li>
</ul>
<p>给定一个<strong>非空</strong>字符串 <em>s</em> 和一个包含<strong>非空</strong>单词的列表 <em>wordDict</em>,判定&nbsp;<em>s</em> 是否可以被空格拆分为一个或多个在字典中出现的单词。</p>
<p><strong>说明:</strong></p>
<ul>
<li>拆分时可以重复使用字典中的单词。</li>
<li>你可以假设字典中没有重复的单词。</li>
</ul>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong> s = &quot;leetcode&quot;, wordDict = [&quot;leet&quot;, &quot;code&quot;]
<strong>输出:</strong> true
<strong>解释:</strong> 返回 true 因为 &quot;leetcode&quot; 可以被拆分成 &quot;leet code&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong> s = &quot;applepenapple&quot;, wordDict = [&quot;apple&quot;, &quot;pen&quot;]
<strong>输出:</strong> true
<strong>解释:</strong> 返回 true 因为 <code>&quot;</code>applepenapple<code>&quot;</code> 可以被拆分成 <code>&quot;</code>apple pen apple<code>&quot;</code>
&nbsp; 注意你可以重复使用字典中的单词。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong> s = &quot;catsandog&quot;, wordDict = [&quot;cats&quot;, &quot;dog&quot;, &quot;sand&quot;, &quot;and&quot;, &quot;cat&quot;]
<strong>输出:</strong> false
</pre>
<p>给你一个 <em>m</em> x <em>n</em> 的网格 <code>grid</code>。网格里的每个单元都代表一条街道。<code>grid[i][j]</code> 的街道可以是:</p>
<ul>
<li><strong>1</strong> 表示连接左单元格和右单元格的街道。</li>
<li><strong>2</strong> 表示连接上单元格和下单元格的街道。</li>
<li><strong>3</strong>&nbsp;表示连接左单元格和下单元格的街道。</li>
<li><strong>4</strong> 表示连接右单元格和下单元格的街道。</li>
<li><strong>5</strong> 表示连接左单元格和上单元格的街道。</li>
<li><strong>6</strong> 表示连接右单元格和上单元格的街道。</li>
</ul>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/main.png" style="height: 708px; width: 450px;"></p>
<p>你最开始从左上角的单元格 <code>(0,0)</code> 开始出发,网格中的「有效路径」是指从左上方的单元格 <code>(0,0)</code> 开始、一直到右下方的 <code>(m-1,n-1)</code> 结束的路径。<strong>该路径必须只沿着街道走</strong></p>
<p><strong>注意:</strong><strong>不能</strong> 变更街道。</p>
<p>如果网格中存在有效的路径,则返回 <code>true</code>,否则返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/e1.png" style="height: 311px; width: 455px;"></p>
<pre><strong>输入:</strong>grid = [[2,4,3],[6,5,2]]
<strong>输出:</strong>true
<strong>解释:</strong>如图所示,你可以从 (0, 0) 开始,访问网格中的所有单元格并到达 (m - 1, n - 1) 。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/21/e2.png" style="height: 293px; width: 455px;"></p>
<pre><strong>输入:</strong>grid = [[1,2,1],[1,2,1]]
<strong>输出:</strong>false
<strong>解释:</strong>如图所示,单元格 (0, 0) 上的街道没有与任何其他单元格上的街道相连,你只会停在 (0, 0) 处。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1,2]]
<strong>输出:</strong>false
<strong>解释:</strong>你会停在 (0, 1),而且无法到达 (0, 2) 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1,1,1,1,1,3]]
<strong>输出:</strong>true
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>grid = [[2],[2],[2],[2],[2],[2],[6]]
<strong>输出:</strong>true
</pre>
<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;= 300</code></li>
<li><code>1 &lt;= grid[i][j] &lt;= 6</code></li>
</ul>
<p>「快乐前缀」是在原字符串中既是&nbsp;<strong>非空</strong> 前缀也是后缀(不包括原字符串自身)的字符串。</p>
<p>给你一个字符串 <code>s</code>,请你返回它的 <strong>最长快乐前缀</strong></p>
<p>如果不存在满足题意的前缀,则返回一个空字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;level&quot;
<strong>输出:</strong>&quot;l&quot;
<strong>解释:</strong>不包括 s 自己,一共有 4 个前缀(&quot;l&quot;, &quot;le&quot;, &quot;lev&quot;, &quot;leve&quot;)和 4 个后缀(&quot;l&quot;, &quot;el&quot;, &quot;vel&quot;, &quot;evel&quot;)。最长的既是前缀也是后缀的字符串是 &quot;l&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;ababab&quot;
<strong>输出:</strong>&quot;abab&quot;
<strong>解释:</strong>&quot;abab&quot; 是最长的既是前缀也是后缀的字符串。题目允许前后缀在原字符串中重叠。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;leetcodeleet&quot;
<strong>输出:</strong>&quot;leet&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;a&quot;
<strong>输出:</strong>&quot;&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s</code> 只含有小写英文字母</li>
</ul>
<p>在整数数组中,如果一个整数的出现频次和它的数值大小相等,我们就称这个整数为「幸运数」。</p>
<p>给你一个整数数组 <code>arr</code>,请你从中找出并返回一个幸运数。</p>
<ul>
<li>如果数组中存在多个幸运数,只需返回 <strong>最大</strong> 的那个。</li>
<li>如果数组中不含幸运数,则返回 <strong>-1 </strong></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [2,2,3,4]
<strong>输出:</strong>2
<strong>解释:</strong>数组中唯一的幸运数是 2 ,因为数值 2 的出现频次也是 2 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,2,3,3,3]
<strong>输出:</strong>3
<strong>解释:</strong>1、2 以及 3 都是幸运数,只需要返回其中最大的 3 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [2,2,2,3,3]
<strong>输出:</strong>-1
<strong>解释:</strong>数组中不存在幸运数。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [5]
<strong>输出:</strong>-1
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [7,7,7,7,7,7,7]
<strong>输出:</strong>7
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 500</code></li>
<li><code>1 &lt;= arr[i] &lt;= 500</code></li>
</ul>
<p> <code>n</code> 名士兵站成一排。每个士兵都有一个 <strong>独一无二</strong> 的评分 <code>rating</code></p>
<p><strong>3</strong> 个士兵可以组成一个作战单位,分组规则如下:</p>
<ul>
<li>从队伍中选出下标分别为 <code>i</code><code>j</code><code>k</code> 的 3 名士兵,他们的评分分别为 <code>rating[i]</code><code>rating[j]</code><code>rating[k]</code></li>
<li>作战单位需满足: <code>rating[i] < rating[j] < rating[k]</code> 或者 <code>rating[i] > rating[j] > rating[k]</code> ,其中  <code><= i j k n</code></li>
</ul>
<p>请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>rating = [2,5,3,4,1]
<strong>输出:</strong>3
<strong>解释:</strong>我们可以组建三个作战单位 (2,3,4)、(5,4,1)、(5,3,1) 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>rating = [2,1,3]
<strong>输出:</strong>0
<strong>解释:</strong>根据题目条件,我们无法组建作战单位。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>rating = [1,2,3,4]
<strong>输出:</strong>4
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == rating.length</code></li>
<li><code>3 <= n <= 1000</code></li>
<li><code>1 <= rating[i] <= 10^5</code></li>
<li><code>rating</code> 中的元素都是唯一的</li>
</ul>
<p>请你实现一个类&nbsp;<code>UndergroundSystem</code>&nbsp;,它支持以下 3 种方法:</p>
<p>1.<code>&nbsp;checkIn(int id, string stationName, int t)</code></p>
<ul>
<li>编号为&nbsp;<code>id</code>&nbsp;的乘客在 <code>t</code>&nbsp;时刻进入地铁站&nbsp;<code>stationName</code>&nbsp;</li>
<li>一个乘客在同一时间只能在一个地铁站进入或者离开。</li>
</ul>
<p>2.<code>&nbsp;checkOut(int id, string stationName, int t)</code></p>
<ul>
<li>编号为&nbsp;<code>id</code>&nbsp;的乘客在 <code>t</code>&nbsp;时刻离开地铁站 <code>stationName</code>&nbsp;</li>
</ul>
<p>3.&nbsp;<code>getAverageTime(string startStation, string endStation)</code>&nbsp;</p>
<ul>
<li>返回从地铁站&nbsp;<code>startStation</code>&nbsp;到地铁站&nbsp;<code>endStation</code>&nbsp;的平均花费时间。</li>
<li>平均时间计算的行程包括当前为止所有从&nbsp;<code>startStation</code>&nbsp;<strong>直接到达</strong>&nbsp;<code>endStation</code>&nbsp;的行程。</li>
<li>调用&nbsp;<code>getAverageTime</code>&nbsp;时,询问的路线至少包含一趟行程。</li>
</ul>
<p>你可以假设所有对&nbsp;<code>checkIn</code>&nbsp;&nbsp;<code>checkOut</code>&nbsp;的调用都是符合逻辑的。也就是说,如果一个顾客在 <strong>t<sub>1</sub></strong>&nbsp;时刻到达某个地铁站,那么他离开的时间&nbsp;<strong>t<sub>2</sub></strong>&nbsp;一定满足&nbsp;<strong>t<sub>2</sub> &gt; t<sub>1</sub></strong>&nbsp;。所有的事件都按时间顺序给出。</p>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>
[&quot;UndergroundSystem&quot;,&quot;checkIn&quot;,&quot;checkIn&quot;,&quot;checkIn&quot;,&quot;checkOut&quot;,&quot;checkOut&quot;,&quot;checkOut&quot;,&quot;getAverageTime&quot;,&quot;getAverageTime&quot;,&quot;checkIn&quot;,&quot;getAverageTime&quot;,&quot;checkOut&quot;,&quot;getAverageTime&quot;]
[[],[45,&quot;Leyton&quot;,3],[32,&quot;Paradise&quot;,8],[27,&quot;Leyton&quot;,10],[45,&quot;Waterloo&quot;,15],[27,&quot;Waterloo&quot;,20],[32,&quot;Cambridge&quot;,22],[&quot;Paradise&quot;,&quot;Cambridge&quot;],[&quot;Leyton&quot;,&quot;Waterloo&quot;],[10,&quot;Leyton&quot;,24],[&quot;Leyton&quot;,&quot;Waterloo&quot;],[10,&quot;Waterloo&quot;,38],[&quot;Leyton&quot;,&quot;Waterloo&quot;]]
<strong>输出:</strong>
[null,null,null,null,null,null,null,14.0,11.0,null,11.0,null,12.0]
<strong>解释:</strong>
UndergroundSystem undergroundSystem = new UndergroundSystem();
undergroundSystem.checkIn(45, &quot;Leyton&quot;, 3);
undergroundSystem.checkIn(32, &quot;Paradise&quot;, 8);
undergroundSystem.checkIn(27, &quot;Leyton&quot;, 10);
undergroundSystem.checkOut(45, &quot;Waterloo&quot;, 15);
undergroundSystem.checkOut(27, &quot;Waterloo&quot;, 20);
undergroundSystem.checkOut(32, &quot;Cambridge&quot;, 22);
undergroundSystem.getAverageTime(&quot;Paradise&quot;, &quot;Cambridge&quot;); // 返回 14.0。从 &quot;Paradise&quot;(时刻 8)到 &quot;Cambridge&quot;(时刻 22)的行程只有一趟
undergroundSystem.getAverageTime(&quot;Leyton&quot;, &quot;Waterloo&quot;); // 返回 11.0。总共有 2 躺从 &quot;Leyton&quot;&quot;Waterloo&quot; 的行程,编号为 id=45 的乘客出发于 time=3 到达于 time=15,编号为 id=27 的乘客于 time=10 出发于 time=20 到达。所以平均时间为 ( (15-3) + (20-10) ) / 2 = 11.0
undergroundSystem.checkIn(10, &quot;Leyton&quot;, 24);
undergroundSystem.getAverageTime(&quot;Leyton&quot;, &quot;Waterloo&quot;); // 返回 11.0
undergroundSystem.checkOut(10, &quot;Waterloo&quot;, 38);
undergroundSystem.getAverageTime(&quot;Leyton&quot;, &quot;Waterloo&quot;); // 返回 12.0</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>总共最多有&nbsp;<code>20000</code>&nbsp;次操作。</li>
<li><code>1 &lt;= id, t &lt;= 10^6</code></li>
<li>所有的字符串包含大写字母,小写字母和数字。</li>
<li><code>1 &lt;=&nbsp;stationName.length &lt;= 10</code></li>
<li>与标准答案误差在&nbsp;<code>10^-5</code>&nbsp;以内的结果都视为正确结果。</li>
</ul>
<p>给你一个字符串 <code>s</code>&nbsp;和一个整数 <code>k</code>&nbsp;。请你用 <code>s</code>&nbsp;字符串中 <strong>所有字符</strong>&nbsp;构造 <code>k</code>&nbsp;个非空 <strong>回文串</strong>&nbsp;</p>
<p>如果你可以用&nbsp;<code>s</code>&nbsp;中所有字符构造&nbsp;<code>k</code>&nbsp;个回文字符串,那么请你返回 <strong>True</strong>&nbsp;,否则返回&nbsp;<strong>False</strong>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;annabelle&quot;, k = 2
<strong>输出:</strong>true
<strong>解释:</strong>可以用 s 中所有字符构造 2 个回文字符串。
一些可行的构造方案包括:&quot;anna&quot; + &quot;elble&quot;&quot;anbna&quot; + &quot;elle&quot;&quot;anellena&quot; + &quot;b&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;leetcode&quot;, k = 3
<strong>输出:</strong>false
<strong>解释:</strong>无法用 s 中所有字符构造 3 个回文串。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;true&quot;, k = 4
<strong>输出:</strong>true
<strong>解释:</strong>唯一可行的方案是让 s 中每个字符单独构成一个字符串。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;yzyzyzyzyzyzyzy&quot;, k = 2
<strong>输出:</strong>true
<strong>解释:</strong>你只需要将所有的 z 放在一个字符串中,所有的 y 放在另一个字符串中。那么两个字符串都是回文串。
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>s = &quot;cr&quot;, k = 7
<strong>输出:</strong>false
<strong>解释:</strong>我们没有足够的字符去构造 7 个回文串。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s</code>&nbsp;中所有字符都是小写英文字母。</li>
<li><code>1 &lt;= k &lt;= 10^5</code></li>
</ul>
<p>给定一个<strong>非空</strong>字符串 <em>s</em> 和一个包含<strong>非空</strong>单词列表的字典 <em>wordDict</em>,在字符串中增加空格来构建一个句子,使得句子中所有的单词都在词典中。返回所有这些可能的句子。</p>
<p><strong>说明:</strong></p>
<ul>
<li>分隔时可以重复使用字典中的单词。</li>
<li>你可以假设字典中没有重复的单词。</li>
</ul>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:
</strong>s = &quot;<code>catsanddog</code>&quot;
wordDict = <code>[&quot;cat&quot;, &quot;cats&quot;, &quot;and&quot;, &quot;sand&quot;, &quot;dog&quot;]</code>
<strong>输出:
</strong><code>[
&nbsp; &quot;cats and dog&quot;,
&nbsp; &quot;cat sand dog&quot;
]</code>
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:
</strong>s = &quot;pineapplepenapple&quot;
wordDict = [&quot;apple&quot;, &quot;pen&quot;, &quot;applepen&quot;, &quot;pine&quot;, &quot;pineapple&quot;]
<strong>输出:
</strong>[
&nbsp; &quot;pine apple pen apple&quot;,
&nbsp; &quot;pineapple pen apple&quot;,
&nbsp; &quot;pine applepen apple&quot;
]
<strong>解释:</strong> 注意你可以重复使用字典中的单词。
</pre>
<p><strong>示例&nbsp;3:</strong></p>
<pre><strong>输入:
</strong>s = &quot;catsandog&quot;
wordDict = [&quot;cats&quot;, &quot;dog&quot;, &quot;sand&quot;, &quot;and&quot;, &quot;cat&quot;]
<strong>输出:
</strong>[]
</pre>
<p>给你一个以 (<code>radius</code>, <code>x_center</code>, <code>y_center</code>) 表示的圆和一个与坐标轴平行的矩形 (<code>x1</code>, <code>y1</code>, <code>x2</code>, <code>y2</code>),其中&nbsp;(<code>x1</code>, <code>y1</code>) 是矩形左下角的坐标,(<code>x2</code>, <code>y2</code>) 是右上角的坐标。</p>
<p>如果圆和矩形有重叠的部分,请你返回 True ,否则返回 False&nbsp;</p>
<p>换句话说,请你检测是否 <strong>存在</strong>&nbsp;(xi, yi) ,它既在圆上也在矩形上(两者都包括点落在边界上的情况)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/04/sample_4_1728.png" style="height: 167px; width: 258px;"></p>
<pre><strong>输入:</strong>radius = 1, x_center = 0, y_center = 0, x1 = 1, y1 = -1, x2 = 3, y2 = 1
<strong>输出:</strong>true
<strong>解释:</strong>圆和矩形有公共点 (1,0)
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/04/sample_2_1728.png" style="height: 135px; width: 150px;"></strong></p>
<pre><strong>输入:</strong>radius = 1, x_center = 0, y_center = 0, x1 = -1, y1 = 0, x2 = 0, y2 = 1
<strong>输出:</strong>true
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/04/sample_6_1728.png" style="height: 165px; width: 175px;"></strong></p>
<pre><strong>输入:</strong>radius = 1, x_center = 1, y_center = 1, x1 = -3, y1 = -3, x2 = 3, y2 = 3
<strong>输出:</strong>true
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>radius = 1, x_center = 1, y_center = 1, x1 = 1, y1 = -3, x2 = 2, y2 = -1
<strong>输出:</strong>false
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= radius &lt;= 2000</code></li>
<li><code>-10^4 &lt;= x_center, y_center, x1, y1, x2, y2 &lt;= 10^4</code></li>
<li><code>x1 &lt; x2</code></li>
<li><code>y1 &lt; y2</code></li>
</ul>
<p>一个厨师收集了他&nbsp;<code>n</code>&nbsp;道菜的满意程度&nbsp;<code>satisfaction</code>&nbsp;,这个厨师做出每道菜的时间都是 1 单位时间。</p>
<p>一道菜的 「喜爱时间」系数定义为烹饪这道菜以及之前每道菜所花费的时间乘以这道菜的满意程度,也就是&nbsp;<code>time[i]</code>*<code>satisfaction[i]</code>&nbsp;</p>
<p>请你返回做完所有菜 「喜爱时间」总和的最大值为多少。</p>
<p>你可以按&nbsp;<strong>任意</strong>&nbsp;顺序安排做菜的顺序,你也可以选择放弃做某些菜来获得更大的总和。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>satisfaction = [-1,-8,0,5,-9]
<strong>输出:</strong>14
<strong>解释:</strong>去掉第二道和最后一道菜,最大的喜爱时间系数和为 (-1*1 + 0*2 + 5*3 = 14) 。每道菜都需要花费 1 单位时间完成。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>satisfaction = [4,3,2]
<strong>输出:</strong>20
<strong>解释:</strong>按照原来顺序相反的时间做菜 (2*1 + 3*2 + 4*3 = 20)
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>satisfaction = [-1,-4,-5]
<strong>输出:</strong>0
<strong>解释:</strong>大家都不喜欢这些菜,所以不做任何菜可以获得最大的喜爱时间系数。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>satisfaction = [-2,5,-1,0,3,-3]
<strong>输出:</strong>35
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == satisfaction.length</code></li>
<li><code>1 &lt;= n &lt;= 500</code></li>
<li><code>-10^3 &lt;=&nbsp;satisfaction[i] &lt;= 10^3</code></li>
</ul>
<p>给你一个数组 <code>nums</code>,请你从中抽取一个子序列,满足该子序列的元素之和 <strong>严格</strong> 大于未包含在该子序列中的各元素之和。</p>
<p>如果存在多个解决方案,只需返回 <strong>长度最小</strong> 的子序列。如果仍然有多个解决方案,则返回 <strong>元素之和最大</strong> 的子序列。</p>
<p>与子数组不同的地方在于,「数组的子序列」不强调元素在原数组中的连续性,也就是说,它可以通过从数组中分离一些(也可能不分离)元素得到。</p>
<p><strong>注意</strong>,题目数据保证满足所有约束条件的解决方案是 <strong>唯一</strong> 的。同时,返回的答案应当按 <strong>非递增顺序</strong> 排列。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [4,3,10,9,8]
<strong>输出:</strong>[10,9]
<strong>解释:</strong>子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列。但是 [10,9] 的元素之和最大。&nbsp;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [4,4,7,6,7]
<strong>输出:</strong>[7,7,6]
<strong>解释:</strong>子序列 [7,7] 的和为 14 ,不严格大于剩下的其他元素之和(14 = 4 + 4 + 6)。因此,[7,6,7] 是满足题意的最小子序列。注意,元素按非递增顺序返回。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [6]
<strong>输出:</strong>[6]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 500</code></li>
<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
</ul>
<p>如果字符串中不含有任何 <code>&#39;aaa&#39;</code><code>&#39;bbb&#39;</code><code>&#39;ccc&#39;</code> 这样的字符串作为子串,那么该字符串就是一个「快乐字符串」。</p>
<p>给你三个整数 <code>a</code><code>b</code><code>c</code>,请你返回 <strong>任意一个</strong> 满足下列全部条件的字符串 <code>s</code></p>
<ul>
<li><code>s</code> 是一个尽可能长的快乐字符串。</li>
<li><code>s</code><strong>最多</strong><code>a</code> 个字母 <code>&#39;a&#39;</code><code>b</code>&nbsp;个字母 <code>&#39;b&#39;</code><code>c</code> 个字母 <code>&#39;c&#39;</code></li>
<li><code>s </code>中只含有 <code>&#39;a&#39;</code><code>&#39;b&#39;</code><code>&#39;c&#39;</code> 三种字母。</li>
</ul>
<p>如果不存在这样的字符串 <code>s</code> ,请返回一个空字符串 <code>&quot;&quot;</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>a = 1, b = 1, c = 7
<strong>输出:</strong>&quot;ccaccbcc&quot;
<strong>解释:</strong>&quot;ccbccacc&quot; 也是一种正确答案。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>a = 2, b = 2, c = 1
<strong>输出:</strong>&quot;aabbc&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>a = 7, b = 1, c = 0
<strong>输出:</strong>&quot;aabaa&quot;
<strong>解释:</strong>这是该测试用例的唯一正确答案。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 &lt;= a, b, c &lt;= 100</code></li>
<li><code>a + b + c &gt; 0</code></li>
</ul>
<p>Alice 和 Bob 用几堆石子在做游戏。几堆石子排成一行,每堆石子都对应一个得分,由数组 <code>stoneValue</code> 给出。</p>
<p>Alice 和 Bob 轮流取石子,<strong>Alice</strong> 总是先开始。在每个玩家的回合中,该玩家可以拿走剩下石子中的的前 <strong>1、2 或 3 堆石子</strong> 。比赛一直持续到所有石头都被拿走。</p>
<p>每个玩家的最终得分为他所拿到的每堆石子的对应得分之和。每个玩家的初始分数都是 <strong>0</strong> 。比赛的目标是决出最高分,得分最高的选手将会赢得比赛,比赛也可能会出现平局。</p>
<p>假设 Alice 和 Bob 都采取 <strong>最优策略</strong> 。如果 Alice 赢了就返回 <em>&quot;Alice&quot;</em> <em></em>Bob 赢了就返回<em> &quot;Bob&quot;</em>平局(分数相同)返回 <em>&quot;Tie&quot;</em></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>values = [1,2,3,7]
<strong>输出:</strong>&quot;Bob&quot;
<strong>解释:</strong>Alice 总是会输,她的最佳选择是拿走前三堆,得分变成 6 。但是 Bob 的得分为 7,Bob 获胜。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>values = [1,2,3,-9]
<strong>输出:</strong>&quot;Alice&quot;
<strong>解释:</strong>Alice 要想获胜就必须在第一个回合拿走前三堆石子,给 Bob 留下负分。
如果 Alice 只拿走第一堆,那么她的得分为 1,接下来 Bob 拿走第二、三堆,得分为 5 。之后 Alice 只能拿到分数 -9 的石子堆,输掉比赛。
如果 Alice 拿走前两堆,那么她的得分为 3,接下来 Bob 拿走第三堆,得分为 3 。之后 Alice 只能拿到分数 -9 的石子堆,同样会输掉比赛。
注意,他们都应该采取 <strong>最优策略 </strong>,所以在这里 Alice 将选择能够使她获胜的方案。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>values = [1,2,3,6]
<strong>输出:</strong>&quot;Tie&quot;
<strong>解释:</strong>Alice 无法赢得比赛。如果她决定选择前三堆,她可以以平局结束比赛,否则她就会输。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>values = [1,2,3,-1,-2,-3,7]
<strong>输出:</strong>&quot;Alice&quot;
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>values = [-1,-2,-3]
<strong>输出:</strong>&quot;Tie&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= values.length &lt;= 50000</code></li>
<li><code>-1000&nbsp;&lt;= values[i] &lt;= 1000</code></li>
</ul>
<p>给你一个字符串数组 <code>words</code> ,数组中的每个字符串都可以看作是一个单词。请你按 <strong>任意</strong> 顺序返回 <code>words</code> 中是其他单词的子字符串的所有单词。</p>
<p>如果你可以删除 <code>words[j]</code>&nbsp;最左侧和/或最右侧的若干字符得到 <code>word[i]</code> ,那么字符串 <code>words[i]</code> 就是 <code>words[j]</code> 的一个子字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>words = [&quot;mass&quot;,&quot;as&quot;,&quot;hero&quot;,&quot;superhero&quot;]
<strong>输出:</strong>[&quot;as&quot;,&quot;hero&quot;]
<strong>解释:</strong>&quot;as&quot;&quot;mass&quot; 的子字符串,&quot;hero&quot;&quot;superhero&quot; 的子字符串。
[&quot;hero&quot;,&quot;as&quot;] 也是有效的答案。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>words = [&quot;leetcode&quot;,&quot;et&quot;,&quot;code&quot;]
<strong>输出:</strong>[&quot;et&quot;,&quot;code&quot;]
<strong>解释:</strong>&quot;et&quot;&quot;code&quot; 都是 &quot;leetcode&quot; 的子字符串。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>words = [&quot;blue&quot;,&quot;green&quot;,&quot;bu&quot;]
<strong>输出:</strong>[]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= words.length &lt;= 100</code></li>
<li><code>1 &lt;= words[i].length &lt;= 30</code></li>
<li><code>words[i]</code> 仅包含小写英文字母。</li>
<li>题目数据 <strong>保证</strong> 每个 <code>words[i]</code> 都是独一无二的。</li>
</ul>
<p>给你一个待查数组 <code>queries</code> ,数组中的元素为 <code>1</code><code>m</code> 之间的正整数。 请你根据以下规则处理所有待查项 <code>queries[i]</code>(从 <code>i=0</code><code>i=queries.length-1</code>):</p>
<ul>
<li>一开始,排列 <code>P=[1,2,3,...,m]</code></li>
<li>对于当前的 <code>i</code> ,请你找出待查项 <code>queries[i]</code> 在排列 <code>P</code> 中的位置(<strong>下标从 0 开始</strong>),然后将其从原位置移动到排列 <code>P</code> 的起始位置(即下标为 0 处)。注意, <code>queries[i]</code><code>P</code> 中的位置就是 <code>queries[i]</code> 的查询结果。</li>
</ul>
<p>请你以数组形式返回待查数组&nbsp; <code>queries</code> 的查询结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>queries = [3,1,2,1], m = 5
<strong>输出:</strong>[2,1,2,1]
<strong>解释:</strong>待查数组 queries 处理如下:
对于 i=0: queries[i]=3, P=[1,2,3,4,5], 3 在 P 中的位置是 <strong>2</strong>,接着我们把 3 移动到 P 的起始位置,得到 P=[3,1,2,4,5] 。
对于 i=1: queries[i]=1, P=[3,1,2,4,5], 1 在 P 中的位置是 <strong>1</strong>,接着我们把 1 移动到 P 的起始位置,得到 P=[1,3,2,4,5] 。
对于 i=2: queries[i]=2, P=[1,3,2,4,5], 2 在 P 中的位置是 <strong>2</strong>,接着我们把 2 移动到 P 的起始位置,得到 P=[2,1,3,4,5] 。
对于 i=3: queries[i]=1, P=[2,1,3,4,5], 1 在 P 中的位置是 <strong>1</strong>,接着我们把 1 移动到 P 的起始位置,得到 P=[1,2,3,4,5] 。
因此,返回的结果数组为 [2,1,2,1] 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>queries = [4,1,2,2], m = 4
<strong>输出:</strong>[3,1,2,0]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>queries = [7,5,5,8,3], m = 8
<strong>输出:</strong>[6,5,0,7,5]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= m &lt;= 10^3</code></li>
<li><code>1 &lt;= queries.length &lt;= m</code></li>
<li><code>1 &lt;= queries[i] &lt;= m</code></li>
</ul>
<p>「HTML&nbsp;实体解析器」 是一种特殊的解析器,它将 HTML 代码作为输入,并用字符本身替换掉所有这些特殊的字符实体。</p>
<p>HTML 里这些特殊字符和它们对应的字符实体包括:</p>
<ul>
<li><strong>双引号:</strong>字符实体为&nbsp;<code>&amp;quot;</code>&nbsp;,对应的字符是&nbsp;<code>&quot;</code>&nbsp;</li>
<li><strong>单引号:</strong>字符实体为&nbsp;<code>&amp;apos;</code>&nbsp;,对应的字符是&nbsp;<code>&#39;</code>&nbsp;</li>
<li><strong>与符号:</strong>字符实体为&nbsp;<code>&amp;amp;</code>&nbsp;,对应对的字符是&nbsp;<code>&amp;</code>&nbsp;</li>
<li><strong>大于号:</strong>字符实体为&nbsp;<code>&amp;gt;</code>&nbsp;,对应的字符是&nbsp;<code>&gt;</code>&nbsp;</li>
<li><strong>小于号:</strong>字符实体为&nbsp;<code>&amp;lt;</code>&nbsp;,对应的字符是&nbsp;<code>&lt;</code>&nbsp;</li>
<li><strong>斜线号:</strong>字符实体为&nbsp;<code>&amp;frasl;</code>&nbsp;,对应的字符是&nbsp;<code>/</code>&nbsp;</li>
</ul>
<p>给你输入字符串&nbsp;<code>text</code>&nbsp;,请你实现一个 HTML&nbsp;实体解析器,返回解析器解析后的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>text = &quot;&amp;amp; is an HTML entity but &amp;ambassador; is not.&quot;
<strong>输出:</strong>&quot;&amp; is an HTML entity but &amp;ambassador; is not.&quot;
<strong>解释:</strong>解析器把字符实体 &amp;amp; 用 &amp; 替换
</pre>
<p><strong>示例&nbsp;2:</strong></p>
<pre>
<strong>输入:</strong>text = &quot;and I quote: &amp;quot;...&amp;quot;&quot;
<strong>输出:</strong>&quot;and I quote: \&quot;...\&quot;&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>text = &quot;Stay home! Practice on Leetcode :)&quot;
<strong>输出:</strong>&quot;Stay home! Practice on Leetcode :)&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>text = &quot;x &amp;gt; y &amp;amp;&amp;amp; x &amp;lt; y is always false&quot;
<strong>输出:</strong>&quot;x &gt; y &amp;&amp; x &lt; y is always false&quot;
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>text = &quot;leetcode.com&amp;frasl;problemset&amp;frasl;all&quot;
<strong>输出:</strong>&quot;leetcode.com/problemset/all&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= text.length &lt;= 10^5</code></li>
<li>字符串可能包含 256 个ASCII 字符中的任意字符。</li>
</ul>
<p>给定一个链表,判断链表中是否有环。</p>
<p>如果链表中有某个节点,可以通过连续跟踪 <code>next</code> 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 <code>pos</code> 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 <code>pos</code><code>-1</code>,则在该链表中没有环。<strong>注意:<code>pos</code> 不作为参数进行传递</strong>,仅仅是为了标识链表的实际情况。</p>
<p>如果链表中存在环,则返回 <code>true</code> 。 否则,返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>进阶:</strong></p>
<p>你能用 <em>O(1)</em>(即,常量)内存解决此问题吗?</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist.png" style="height: 97px; width: 300px;"></p>
<pre><strong>输入:</strong>head = [3,2,0,-4], pos = 1
<strong>输出:</strong>true
<strong>解释:</strong>链表中有一个环,其尾部连接到第二个节点。
</pre>
<p><strong>示例&nbsp;2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png" style="height: 74px; width: 141px;"></p>
<pre><strong>输入:</strong>head = [1,2], pos = 0
<strong>输出:</strong>true
<strong>解释:</strong>链表中有一个环,其尾部连接到第一个节点。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png" style="height: 45px; width: 45px;"></p>
<pre><strong>输入:</strong>head = [1], pos = -1
<strong>输出:</strong>false
<strong>解释:</strong>链表中没有环。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>链表中节点的数目范围是 <code>[0, 10<sup>4</sup>]</code></li>
<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
<li><code>pos</code><code>-1</code> 或者链表中的一个 <strong>有效索引</strong></li>
</ul>
<p>你有一个 <code>n x 3</code>&nbsp;的网格图 <code>grid</code>&nbsp;,你需要用 <strong>红,黄,绿</strong>&nbsp;三种颜色之一给每一个格子上色,且确保相邻格子颜色不同(也就是有相同水平边或者垂直边的格子颜色不同)。</p>
<p>给你网格图的行数 <code>n</code>&nbsp;</p>
<p>请你返回给&nbsp;<code>grid</code>&nbsp;涂色的方案数。由于答案可能会非常大,请你返回答案对&nbsp;<code>10^9 + 7</code>&nbsp;取余的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 1
<strong>输出:</strong>12
<strong>解释:</strong>总共有 12 种可行的方法:
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/12/e1.png" style="height: 289px; width: 450px;">
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>54
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 3
<strong>输出:</strong>246
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 7
<strong>输出:</strong>106494
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 5000
<strong>输出:</strong>30228214
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == grid.length</code></li>
<li><code>grid[i].length == 3</code></li>
<li><code>1 &lt;= n &lt;= 5000</code></li>
</ul>
<p>给你一个混合了数字和字母的字符串 <code>s</code>,其中的字母均为小写英文字母。</p>
<p>请你将该字符串重新格式化,使得任意两个相邻字符的类型都不同。也就是说,字母后面应该跟着数字,而数字后面应该跟着字母。</p>
<p>请你返回 <strong>重新格式化后</strong> 的字符串;如果无法按要求重新格式化,则返回一个 <strong>空字符串</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;a0b1c2&quot;
<strong>输出:</strong>&quot;0a1b2c&quot;
<strong>解释:</strong>&quot;0a1b2c&quot; 中任意两个相邻字符的类型都不同。 &quot;a0b1c2&quot;, &quot;0a1b2c&quot;, &quot;0c2a1b&quot; 也是满足题目要求的答案。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;leetcode&quot;
<strong>输出:</strong>&quot;&quot;
<strong>解释:</strong>&quot;leetcode&quot; 中只有字母,所以无法满足重新格式化的条件。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;1229857369&quot;
<strong>输出:</strong>&quot;&quot;
<strong>解释:</strong>&quot;1229857369&quot; 中只有数字,所以无法满足重新格式化的条件。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;covid2019&quot;
<strong>输出:</strong>&quot;c2o0v1i9d&quot;
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>s = &quot;ab123&quot;
<strong>输出:</strong>&quot;1a2b3&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 500</code></li>
<li><code>s</code> 仅由小写英文字母和/或数字组成。</li>
</ul>
<p>给你一个数组 <code>orders</code>,表示客户在餐厅中完成的订单,确切地说, <code>orders[i]=[customerName<sub>i</sub>,tableNumber<sub>i</sub>,foodItem<sub>i</sub>]</code> ,其中 <code>customerName<sub>i</sub></code> 是客户的姓名,<code>tableNumber<sub>i</sub></code> 是客户所在餐桌的桌号,而 <code>foodItem<sub>i</sub></code> 是客户点的餐品名称。</p>
<p>请你返回该餐厅的 <strong>点菜展示表</strong><em></em>在这张表中,表中第一行为标题,其第一列为餐桌桌号 &ldquo;Table&rdquo; ,后面每一列都是按字母顺序排列的餐品名称。接下来每一行中的项则表示每张餐桌订购的相应餐品数量,第一列应当填对应的桌号,后面依次填写下单的餐品数量。</p>
<p>注意:客户姓名不是点菜展示表的一部分。此外,表中的数据行应该按餐桌桌号升序排列。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>orders = [[&quot;David&quot;,&quot;3&quot;,&quot;Ceviche&quot;],[&quot;Corina&quot;,&quot;10&quot;,&quot;Beef Burrito&quot;],[&quot;David&quot;,&quot;3&quot;,&quot;Fried Chicken&quot;],[&quot;Carla&quot;,&quot;5&quot;,&quot;Water&quot;],[&quot;Carla&quot;,&quot;5&quot;,&quot;Ceviche&quot;],[&quot;Rous&quot;,&quot;3&quot;,&quot;Ceviche&quot;]]
<strong>输出:</strong>[[&quot;Table&quot;,&quot;Beef Burrito&quot;,&quot;Ceviche&quot;,&quot;Fried Chicken&quot;,&quot;Water&quot;],[&quot;3&quot;,&quot;0&quot;,&quot;2&quot;,&quot;1&quot;,&quot;0&quot;],[&quot;5&quot;,&quot;0&quot;,&quot;1&quot;,&quot;0&quot;,&quot;1&quot;],[&quot;10&quot;,&quot;1&quot;,&quot;0&quot;,&quot;0&quot;,&quot;0&quot;]]
<strong>解释:
</strong>点菜展示表如下所示:
<strong>Table,Beef Burrito,Ceviche,Fried Chicken,Water</strong>
3 ,0 ,2 ,1 ,0
5 ,0 ,1 ,0 ,1
10 ,1 ,0 ,0 ,0
对于餐桌 3:David 点了 &quot;Ceviche&quot;&quot;Fried Chicken&quot;,而 Rous 点了 &quot;Ceviche&quot;
而餐桌 5:Carla 点了 &quot;Water&quot;&quot;Ceviche&quot;
餐桌 10:Corina 点了 &quot;Beef Burrito&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>orders = [[&quot;James&quot;,&quot;12&quot;,&quot;Fried Chicken&quot;],[&quot;Ratesh&quot;,&quot;12&quot;,&quot;Fried Chicken&quot;],[&quot;Amadeus&quot;,&quot;12&quot;,&quot;Fried Chicken&quot;],[&quot;Adam&quot;,&quot;1&quot;,&quot;Canadian Waffles&quot;],[&quot;Brianna&quot;,&quot;1&quot;,&quot;Canadian Waffles&quot;]]
<strong>输出:</strong>[[&quot;Table&quot;,&quot;Canadian Waffles&quot;,&quot;Fried Chicken&quot;],[&quot;1&quot;,&quot;2&quot;,&quot;0&quot;],[&quot;12&quot;,&quot;0&quot;,&quot;3&quot;]]
<strong>解释:</strong>
对于餐桌 1:Adam 和 Brianna 都点了 &quot;Canadian Waffles&quot;
而餐桌 12:James, Ratesh 和 Amadeus 都点了 &quot;Fried Chicken&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>orders = [[&quot;Laura&quot;,&quot;2&quot;,&quot;Bean Burrito&quot;],[&quot;Jhon&quot;,&quot;2&quot;,&quot;Beef Burrito&quot;],[&quot;Melissa&quot;,&quot;2&quot;,&quot;Soda&quot;]]
<strong>输出:</strong>[[&quot;Table&quot;,&quot;Bean Burrito&quot;,&quot;Beef Burrito&quot;,&quot;Soda&quot;],[&quot;2&quot;,&quot;1&quot;,&quot;1&quot;,&quot;1&quot;]]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;orders.length &lt;= 5 * 10^4</code></li>
<li><code>orders[i].length == 3</code></li>
<li><code>1 &lt;= customerName<sub>i</sub>.length, foodItem<sub>i</sub>.length &lt;= 20</code></li>
<li><code>customerName<sub>i</sub></code><code>foodItem<sub>i</sub></code> 由大小写英文字母及空格字符 <code>&#39; &#39;</code> 组成。</li>
<li><code>tableNumber<sub>i</sub></code><code>1</code><code>500</code> 范围内的整数。</li>
</ul>
<p>给你一个字符串 <code>croakOfFrogs</code>,它表示不同青蛙发出的蛙鸣声(字符串 &quot;croak&quot; )的组合。由于同一时间可以有多只青蛙呱呱作响,所以&nbsp;<code>croakOfFrogs</code> 中会混合多个 &ldquo;croak&rdquo; <em></em>请你返回模拟字符串中所有蛙鸣所需不同青蛙的最少数目。</p>
<p><strong>注意:</strong>要想发出蛙鸣 &quot;croak&quot;,青蛙必须 <strong>依序</strong> 输出 <code>&lsquo;c&rsquo;, &rsquo;r&rsquo;, &rsquo;o&rsquo;, &rsquo;a&rsquo;, &rsquo;k&rsquo;</code> 这 5 个字母。如果没有输出全部五个字母,那么它就不会发出声音。</p>
<p>如果字符串 <code>croakOfFrogs</code> 不是由若干有效的 &quot;croak&quot; 字符混合而成,请返回 <code>-1</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>croakOfFrogs = &quot;croakcroak&quot;
<strong>输出:</strong>1
<strong>解释:</strong>一只青蛙 &ldquo;呱呱&rdquo; 两次
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>croakOfFrogs = &quot;crcoakroak&quot;
<strong>输出:</strong>2
<strong>解释:</strong>最少需要两只青蛙,&ldquo;呱呱&rdquo; 声用黑体标注
第一只青蛙 &quot;<strong>cr</strong>c<strong>oak</strong>roak&quot;
第二只青蛙 &quot;cr<strong>c</strong>oak<strong>roak</strong>&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>croakOfFrogs = &quot;croakcrook&quot;
<strong>输出:</strong>-1
<strong>解释:</strong>给出的字符串不是 &quot;croak<strong>&quot;</strong> 的有效组合。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>croakOfFrogs = &quot;croakcroa&quot;
<strong>输出:</strong>-1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;croakOfFrogs.length &lt;= 10^5</code></li>
<li>字符串中的字符只有 <code>&#39;c&#39;</code>, <code>&#39;r&#39;</code>, <code>&#39;o&#39;</code>, <code>&#39;a&#39;</code> 或者 <code>&#39;k&#39;</code></li>
</ul>
<p>给你三个整数 <code>n</code><code>m</code><code>k</code> 。下图描述的算法用于找出正整数数组中最大的元素。</p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/19/e.png" style="height: 372px; width: 424px;"></p>
<p>请你生成一个具有下述属性的数组 <code>arr</code></p>
<ul>
<li><code>arr</code> 中有 <code>n</code> 个整数。</li>
<li><code>1 &lt;= arr[i] &lt;= m</code> 其中 <code>(0 &lt;= i &lt; n)</code></li>
<li>将上面提到的算法应用于 <code>arr</code><code>search_cost</code> 的值等于 <code>k</code></li>
</ul>
<p>返回上述条件下生成数组 <code>arr</code><strong>方法数</strong> ,由于答案可能会很大,所以 <strong>必须</strong><code>10^9 + 7</code> 取余。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 2, m = 3, k = 1
<strong>输出:</strong>6
<strong>解释:</strong>可能的数组分别为 [1, 1], [2, 1], [2, 2], [3, 1], [3, 2] [3, 3]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 5, m = 2, k = 3
<strong>输出:</strong>0
<strong>解释:</strong>没有数组可以满足上述条件
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 9, m = 1, k = 1
<strong>输出:</strong>1
<strong>解释:</strong>可能的数组只有 [1, 1, 1, 1, 1, 1, 1, 1, 1]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 50, m = 100, k = 25
<strong>输出:</strong>34549172
<strong>解释:</strong>不要忘了对 1000000007 取余
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 37, m = 17, k = 7
<strong>输出:</strong>418930126
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 50</code></li>
<li><code>1 &lt;= m &lt;= 100</code></li>
<li><code>0 &lt;= k &lt;= n</code></li>
</ul>
<p>给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 <code>null</code></p>
<p>为了表示给定链表中的环,我们使用整数 <code>pos</code> 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 <code>pos</code><code>-1</code>,则在该链表中没有环。<strong>注意,<code>pos</code> 仅仅是用于标识环的情况,并不会作为参数传递到函数中。</strong></p>
<p><strong>说明:</strong>不允许修改给定的链表。</p>
<p><strong>进阶:</strong></p>
<ul>
<li>你是否可以使用 <code>O(1)</code> 空间解决此题?</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist.png" style="height: 97px; width: 300px;" /></p>
<pre>
<strong>输入:</strong>head = [3,2,0,-4], pos = 1
<strong>输出:</strong>返回索引为 1 的链表节点
<strong>解释:</strong>链表中有一个环,其尾部连接到第二个节点。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png" style="height: 74px; width: 141px;" /></p>
<pre>
<strong>输入:</strong>head = [1,2], pos = 0
<strong>输出:</strong>返回索引为 0 的链表节点
<strong>解释:</strong>链表中有一个环,其尾部连接到第一个节点。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png" style="height: 45px; width: 45px;" /></p>
<pre>
<strong>输入:</strong>head = [1], pos = -1
<strong>输出:</strong>返回 null
<strong>解释:</strong>链表中没有环。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>链表中节点的数目范围在范围 <code>[0, 10<sup>4</sup>]</code></li>
<li><code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code></li>
<li><code>pos</code> 的值为 <code>-1</code> 或者链表中的一个有效索引</li>
</ul>
<p>给你一个由若干 0 和 1 组成的字符串 <code>s</code> ,请你计算并返回将该字符串分割成两个 <strong>非空</strong> 子字符串(即&nbsp;<strong></strong> 子字符串和 <strong></strong> 子字符串)所能获得的最大得分。</p>
<p>「分割字符串的得分」为 <strong></strong> 子字符串中 <strong>0</strong> 的数量加上 <strong></strong> 子字符串中 <strong>1</strong> 的数量。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;011101&quot;
<strong>输出:</strong>5
<strong>解释:</strong>
将字符串 s 划分为两个非空子字符串的可行方案有:
左子字符串 = &quot;0&quot; 且 右子字符串 = &quot;11101&quot;,得分 = 1 + 4 = 5
左子字符串 = &quot;01&quot; 且 右子字符串 = &quot;1101&quot;,得分 = 1 + 3 = 4
左子字符串 = &quot;011&quot; 且 右子字符串 = &quot;101&quot;,得分 = 1 + 2 = 3
左子字符串 = &quot;0111&quot; 且 右子字符串 = &quot;01&quot;,得分 = 1 + 1 = 2
左子字符串 = &quot;01110&quot; 且 右子字符串 = &quot;1&quot;,得分 = 2 + 1 = 3
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;00111&quot;
<strong>输出:</strong>5
<strong>解释:</strong>当 左子字符串 = &quot;00&quot; 且 右子字符串 = &quot;111&quot; 时,我们得到最大得分 = 2 + 3 = 5
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;1111&quot;
<strong>输出:</strong>3
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= s.length &lt;= 500</code></li>
<li>字符串 <code>s</code> 仅由字符 <code>&#39;0&#39;</code><code>&#39;1&#39;</code> 组成。</li>
</ul>
<p>几张卡牌<strong> 排成一行</strong>,每张卡牌都有一个对应的点数。点数由整数数组 <code>cardPoints</code> 给出。</p>
<p>每次行动,你可以从行的开头或者末尾拿一张卡牌,最终你必须正好拿 <code>k</code> 张卡牌。</p>
<p>你的点数就是你拿到手中的所有卡牌的点数之和。</p>
<p>给你一个整数数组 <code>cardPoints</code> 和整数 <code>k</code>,请你返回可以获得的最大点数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>cardPoints = [1,2,3,4,5,6,1], k = 3
<strong>输出:</strong>12
<strong>解释:</strong>第一次行动,不管拿哪张牌,你的点数总是 1 。但是,先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌,最终点数为 1 + 6 + 5 = 12 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>cardPoints = [2,2,2], k = 2
<strong>输出:</strong>4
<strong>解释:</strong>无论你拿起哪两张卡牌,可获得的点数总是 4 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>cardPoints = [9,7,7,9,7,7,9], k = 7
<strong>输出:</strong>55
<strong>解释:</strong>你必须拿起所有卡牌,可以获得的点数为所有卡牌的点数之和。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>cardPoints = [1,1000,1], k = 1
<strong>输出:</strong>1
<strong>解释:</strong>你无法拿到中间那张卡牌,所以可以获得的最大点数为 1 。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>cardPoints = [1,79,80,1,1,1,200,1], k = 3
<strong>输出:</strong>202
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= cardPoints.length &lt;= 10^5</code></li>
<li><code>1 &lt;= cardPoints[i] &lt;= 10^4</code></li>
<li><code>1 &lt;= k &lt;= cardPoints.length</code></li>
</ul>
<p>给你一个列表&nbsp;<code>nums</code>&nbsp;,里面每一个元素都是一个整数列表。请你依照下面各图的规则,按顺序返回&nbsp;<code>nums</code>&nbsp;中对角线上的整数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/23/sample_1_1784.png" style="height: 143px; width: 158px;"></strong></p>
<pre><strong>输入:</strong>nums = [[1,2,3],[4,5,6],[7,8,9]]
<strong>输出:</strong>[1,4,2,7,5,3,8,6,9]
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/04/23/sample_2_1784.png" style="height: 177px; width: 230px;"></strong></p>
<pre><strong>输入:</strong>nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
<strong>输出:</strong>[1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [[1,2,3],[4],[5,6,7],[8],[9,10,11]]
<strong>输出:</strong>[1,4,2,5,3,8,6,9,7,10,11]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums = [[1,2,3,4,5,6]]
<strong>输出:</strong>[1,2,3,4,5,6]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums[i].length &lt;=&nbsp;10^5</code></li>
<li><code>1 &lt;= nums[i][j] &lt;= 10^9</code></li>
<li><code>nums</code>&nbsp;中最多有&nbsp;<code>10^5</code>&nbsp;个数字。</li>
</ul>
<p>给你一个整数数组&nbsp;<code>nums</code>&nbsp;和一个整数&nbsp;<code>k</code>&nbsp;,请你返回 <strong>非空</strong>&nbsp;子序列元素和的最大值,子序列需要满足:子序列中每两个 <strong>相邻</strong>&nbsp;的整数&nbsp;<code>nums[i]</code>&nbsp;&nbsp;<code>nums[j]</code>&nbsp;,它们在原数组中的下标&nbsp;<code>i</code>&nbsp;&nbsp;<code>j</code>&nbsp;满足&nbsp;<code>i &lt; j</code>&nbsp;<code>j - i &lt;= k</code></p>
<p>数组的子序列定义为:将数组中的若干个数字删除(可以删除 0 个数字),剩下的数字按照原本的顺序排布。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [10,2,-10,5,20], k = 2
<strong>输出:</strong>37
<strong>解释:</strong>子序列为 [10, 2, 5, 20] 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [-1,-2,-3], k = 1
<strong>输出:</strong>-1
<strong>解释:</strong>子序列必须是非空的,所以我们选择最大的数字。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [10,-2,-10,-5,20], k = 2
<strong>输出:</strong>23
<strong>解释:</strong>子序列为 [10, -2, -5, 20] 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= k &lt;= nums.length &lt;= 10^5</code></li>
<li><code>-10^4&nbsp;&lt;= nums[i] &lt;= 10^4</code></li>
</ul>
<p>给定一个单链表 <code>L</code><em> </em>的头节点 <code>head</code> ,单链表 <code>L</code> 表示为:</p>
<p><code> L<sub></sub>→ L<sub></sub>→ … → L<sub>n-1 </sub>→ L<sub></sub></code><br />
请将其重新排列后变为:</p>
<p><code>L<sub></sub>→ L<sub></sub>→ L<sub></sub>→ L<sub>n-1 </sub>→ L<sub></sub>→ L<sub>n-2 </sub>→ …</code></p>
<p>不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://pic.leetcode-cn.com/1626420311-PkUiGI-image.png" style="width: 240px; " /></p>
<pre>
<strong>输入: </strong>head = [1,2,3,4]
<strong>输出: </strong>[1,4,2,3]</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://pic.leetcode-cn.com/1626420320-YUiulT-image.png" style="width: 320px; " /></p>
<pre>
<strong>输入: </strong>head = [1,2,3,4,5]
<strong>输出: </strong>[1,5,2,4,3]</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>链表的长度范围为 <code>[1, 5 * 10<sup>4</sup>]</code></li>
<li><code>1 <= node.val <= 1000</code></li>
</ul>
<p>给你一个数组&nbsp;<code>candies</code>&nbsp;和一个整数&nbsp;<code>extraCandies</code>&nbsp;,其中&nbsp;<code>candies[i]</code>&nbsp;代表第 <code>i</code> 个孩子拥有的糖果数目。</p>
<p>对每一个孩子,检查是否存在一种方案,将额外的&nbsp;<code>extraCandies</code>&nbsp;个糖果分配给孩子们之后,此孩子有 <strong>最多</strong>&nbsp;的糖果。注意,允许有多个孩子同时拥有 <strong>最多</strong>&nbsp;的糖果数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>candies = [2,3,5,1,3], extraCandies = 3
<strong>输出:</strong>[true,true,true,false,true]
<strong>解释:</strong>
孩子 1 有 2 个糖果,如果他得到所有额外的糖果(3个),那么他总共有 5 个糖果,他将成为拥有最多糖果的孩子。
孩子 2 有 3 个糖果,如果他得到至少 2 个额外糖果,那么他将成为拥有最多糖果的孩子。
孩子 3 有 5 个糖果,他已经是拥有最多糖果的孩子。
孩子 4 有 1 个糖果,即使他得到所有额外的糖果,他也只有 4 个糖果,无法成为拥有糖果最多的孩子。
孩子 5 有 3 个糖果,如果他得到至少 2 个额外糖果,那么他将成为拥有最多糖果的孩子。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>candies = [4,2,1,1,2], extraCandies = 1
<strong>输出:</strong>[true,false,false,false,false]
<strong>解释:</strong>只有 1 个额外糖果,所以不管额外糖果给谁,只有孩子 1 可以成为拥有糖果最多的孩子。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>candies = [12,1,12], extraCandies = 10
<strong>输出:</strong>[true,false,true]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= candies.length &lt;= 100</code></li>
<li><code>1 &lt;= candies[i] &lt;= 100</code></li>
<li><code>1 &lt;= extraCandies &lt;= 50</code></li>
</ul>
<p>给你一个整数&nbsp;<code>num</code>&nbsp;。你可以对它进行如下步骤恰好 <strong>两次</strong>&nbsp;</p>
<ul>
<li>选择一个数字&nbsp;<code>x (0&nbsp;&lt;= x &lt;= 9)</code>.</li>
<li>选择另一个数字&nbsp;<code>y (0&nbsp;&lt;= y &lt;= 9)</code>&nbsp;。数字&nbsp;<code>y</code>&nbsp;可以等于&nbsp;<code>x</code>&nbsp;</li>
<li><code>num</code>&nbsp;中所有出现 <code>x</code>&nbsp;的数位都用 <code>y</code>&nbsp;替换。</li>
<li>得到的新的整数 <strong>不能</strong>&nbsp;有前导 0 ,得到的新整数也 <strong>不能</strong>&nbsp;是 0&nbsp;</li>
</ul>
<p>令两次对 <code>num</code>&nbsp;的操作得到的结果分别为&nbsp;<code>a</code>&nbsp;&nbsp;<code>b</code>&nbsp;</p>
<p>请你返回&nbsp;<code>a</code>&nbsp;<code>b</code>&nbsp;<strong>最大差值</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>num = 555
<strong>输出:</strong>888
<strong>解释:</strong>第一次选择 x = 5 且 y = 9 ,并把得到的新数字保存在 a 中。
第二次选择 x = 5 且 y = 1 ,并把得到的新数字保存在 b 中。
现在,我们有 a = 999 和 b = 111 ,最大差值为 888
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>num = 9
<strong>输出:</strong>8
<strong>解释:</strong>第一次选择 x = 9 且 y = 9 ,并把得到的新数字保存在 a 中。
第二次选择 x = 9 且 y = 1 ,并把得到的新数字保存在 b 中。
现在,我们有 a = 9 和 b = 1 ,最大差值为 8
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>num = 123456
<strong>输出:</strong>820000
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>num = 10000
<strong>输出:</strong>80000
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>num = 9288
<strong>输出:</strong>8700
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= num &lt;= 10^8</code></li>
</ul>
<p>给你两个字符串&nbsp;<code>s1</code>&nbsp;&nbsp;<code>s2</code>&nbsp;,它们长度相等,请你检查是否存在一个&nbsp;<code>s1</code>&nbsp; 的排列可以打破 <code>s2</code>&nbsp;的一个排列,或者是否存在一个&nbsp;<code>s2</code>&nbsp;的排列可以打破 <code>s1</code> 的一个排列。</p>
<p>字符串&nbsp;<code>x</code>&nbsp;可以打破字符串&nbsp;<code>y</code>&nbsp;(两者长度都为&nbsp;<code>n</code>&nbsp;)需满足对于所有&nbsp;<code>i</code>(在&nbsp;<code>0</code>&nbsp;&nbsp;<code>n - 1</code>&nbsp;之间)都有&nbsp;<code>x[i] &gt;= y[i]</code>(字典序意义下的顺序)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;abc&quot;, s2 = &quot;xya&quot;
<strong>输出:</strong>true
<strong>解释:</strong>&quot;ayx&quot; 是 s2=&quot;xya&quot; 的一个排列,&quot;abc&quot; 是字符串 s1=&quot;abc&quot; 的一个排列,且 &quot;ayx&quot; 可以打破 &quot;abc&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;abe&quot;, s2 = &quot;acd&quot;
<strong>输出:</strong>false
<strong>解释:</strong>s1=&quot;abe&quot; 的所有排列包括:&quot;abe&quot;&quot;aeb&quot;&quot;bae&quot;&quot;bea&quot;&quot;eab&quot;&quot;eba&quot; ,s2=&quot;acd&quot; 的所有排列包括:&quot;acd&quot;&quot;adc&quot;&quot;cad&quot;&quot;cda&quot;&quot;dac&quot;&quot;dca&quot;。然而没有任何 s1 的排列可以打破 s2 的排列。也没有 s2 的排列能打破 s1 的排列。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s1 = &quot;leetcodee&quot;, s2 = &quot;interview&quot;
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>s1.length == n</code></li>
<li><code>s2.length == n</code></li>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li>所有字符串都只包含小写英文字母。</li>
</ul>
<p>总共有 <code>n</code>&nbsp;个人和 <code>40</code> 种不同的帽子,帽子编号从 <code>1</code><code>40</code></p>
<p>给你一个整数列表的列表&nbsp;<code>hats</code>&nbsp;,其中&nbsp;<code>hats[i]</code>&nbsp;是第 <code>i</code>&nbsp;个人所有喜欢帽子的列表。</p>
<p>请你给每个人安排一顶他喜欢的帽子,确保每个人戴的帽子跟别人都不一样,并返回方案数。</p>
<p>由于答案可能很大,请返回它对&nbsp;<code>10^9 + 7</code>&nbsp;取余后的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>hats = [[3,4],[4,5],[5]]
<strong>输出:</strong>1
<strong>解释:</strong>给定条件下只有一种方法选择帽子。
第一个人选择帽子 3,第二个人选择帽子 4,最后一个人选择帽子 5。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>hats = [[3,5,1],[3,5]]
<strong>输出:</strong>4
<strong>解释:</strong>总共有 4 种安排帽子的方法:
(3,5),(5,3),(1,3) 和 (1,5)
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>hats = [[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]]
<strong>输出:</strong>24
<strong>解释:</strong>每个人都可以从编号为 1 到 4 的帽子中选。
(1,2,3,4) 4 个帽子的排列方案数为 24 。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>hats = [[1,2,3],[2,3,5,6],[1,3,7,9],[1,8,9],[2,5,7]]
<strong>输出:</strong>111
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == hats.length</code></li>
<li><code>1 &lt;= n &lt;= 10</code></li>
<li><code>1 &lt;= hats[i].length &lt;= 40</code></li>
<li><code>1 &lt;= hats[i][j] &lt;= 40</code></li>
<li><code>hats[i]</code>&nbsp;包含一个数字互不相同的整数列表。</li>
</ul>
<p>给你一份旅游线路图,该线路图中的旅行线路用数组 <code>paths</code> 表示,其中 <code>paths[i] = [cityA<sub>i</sub>, cityB<sub>i</sub>]</code> 表示该线路将会从 <code>cityA<sub>i</sub></code> 直接前往 <code>cityB<sub>i</sub></code> 。请你找出这次旅行的终点站,即没有任何可以通往其他城市的线路的城市<em></em></p>
<p>题目数据保证线路图会形成一条不存在循环的线路,因此恰有一个旅行终点站。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
<strong>输出:</strong>"Sao Paulo"
<strong>解释:</strong>从 "London" 出发,最后抵达终点站 "Sao Paulo" 。本次旅行的路线是 "London" -&gt; "New York" -&gt; "Lima" -&gt; "Sao Paulo" 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>paths = [["B","C"],["D","B"],["C","A"]]
<strong>输出:</strong>"A"
<strong>解释:</strong>所有可能的线路是:
"D" -&gt; "B" -&gt; "C" -&gt; "A".&nbsp;
"B" -&gt; "C" -&gt; "A".&nbsp;
"C" -&gt; "A".&nbsp;
"A".&nbsp;
显然,旅行终点站是 "A" 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>paths = [["A","Z"]]
<strong>输出:</strong>"Z"
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= paths.length &lt;= 100</code></li>
<li><code>paths[i].length == 2</code></li>
<li><code>1 &lt;=&nbsp;cityA<sub>i</sub>.length,&nbsp;cityB<sub>i</sub>.length &lt;= 10</code></li>
<li><code>cityA<sub>i&nbsp;</sub>!=&nbsp;cityB<sub>i</sub></code></li>
<li>所有字符串均由大小写英文字母和空格字符组成。</li>
</ul>
<p>给你一个由若干 <code>0</code><code>1</code> 组成的数组 <code>nums</code> 以及整数 <code>k</code>。如果所有 <code>1</code> 都至少相隔 <code>k</code> 个元素,则返回 <code>True</code> ;否则,返回 <code>False</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/03/sample_1_1791.png" style="width: 214px;"></strong></p>
<pre><strong>输入:</strong>nums = [1,0,0,0,1,0,0,1], k = 2
<strong>输出:</strong>true
<strong>解释:</strong>每个 1 都至少相隔 2 个元素。</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/03/sample_2_1791.png" style="height: 86px; width: 160px;"></strong></p>
<pre><strong>输入:</strong>nums = [1,0,0,1,0,1], k = 2
<strong>输出:</strong>false
<strong>解释:</strong>第二个 1 和第三个 1 之间只隔了 1 个元素。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,1,1,1], k = 0
<strong>输出:</strong>true
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums = [0,1,0,1], k = 1
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>0 &lt;= k &lt;= nums.length</code></li>
<li><code>nums[i]</code> 的值为 <code>0</code><code>1</code></li>
</ul>
<p>给你一个整数数组 <code>nums</code> ,和一个表示限制的整数 <code>limit</code>,请你返回最长连续子数组的长度,该子数组中的任意两个元素之间的绝对差必须小于或者等于 <code>limit</code><em></em></p>
<p>如果不存在满足条件的子数组,则返回 <code>0</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [8,2,4,7], limit = 4
<strong>输出:</strong>2
<strong>解释:</strong>所有子数组如下:
[8] 最大绝对差 |8-8| = 0 &lt;= 4.
[8,2] 最大绝对差 |8-2| = 6 &gt; 4.
[8,2,4] 最大绝对差 |8-2| = 6 &gt; 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 &gt; 4.
[2] 最大绝对差 |2-2| = 0 &lt;= 4.
[2,4] 最大绝对差 |2-4| = 2 &lt;= 4.
[2,4,7] 最大绝对差 |2-7| = 5 &gt; 4.
[4] 最大绝对差 |4-4| = 0 &lt;= 4.
[4,7] 最大绝对差 |4-7| = 3 &lt;= 4.
[7] 最大绝对差 |7-7| = 0 &lt;= 4.
因此,满足题意的最长子数组的长度为 2 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [10,1,2,4,7,2], limit = 5
<strong>输出:</strong>4
<strong>解释:</strong>满足题意的最长子数组是 [2,4,7,2],其最大绝对差 |2-7| = 5 &lt;= 5 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [4,2,2,2,4,4,2,2], limit = 0
<strong>输出:</strong>3
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^9</code></li>
<li><code>0 &lt;= limit &lt;= 10^9</code></li>
</ul>
<p>给你一个 <code>m&nbsp;* n</code> 的矩阵 <code>mat</code>,以及一个整数 <code>k</code> ,矩阵中的每一行都以非递减的顺序排列。</p>
<p>你可以从每一行中选出 1 个元素形成一个数组。返回所有可能数组中的第 k 个 <strong>最小</strong> 数组和。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>mat = [[1,3,11],[2,4,6]], k = 5
<strong>输出:</strong>7
<strong>解释:</strong>从每一行中选出一个元素,前 k 个和最小的数组分别是:
[1,2], [1,4], [3,2], [3,4], [1,6]。其中第 5 个的和是 7 。 </pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>mat = [[1,3,11],[2,4,6]], k = 9
<strong>输出:</strong>17
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>mat = [[1,10,10],[1,4,5],[2,3,6]], k = 7
<strong>输出:</strong>9
<strong>解释:</strong>从每一行中选出一个元素,前 k 个和最小的数组分别是:
[1,1,2], [1,1,3], [1,4,2], [1,4,3], [1,1,6], [1,5,2], [1,5,3]。其中第 7 个的和是 9 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>mat = [[1,1,10],[2,2,9]], k = 7
<strong>输出:</strong>12
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == mat.length</code></li>
<li><code>n == mat.length[i]</code></li>
<li><code>1 &lt;= m, n &lt;= 40</code></li>
<li><code>1 &lt;= k &lt;= min(200, n ^&nbsp;m)</code></li>
<li><code>1 &lt;= mat[i][j] &lt;= 5000</code></li>
<li><code>mat[i]</code> 是一个非递减数组</li>
</ul>
<p>给你二叉树的根节点 <code>root</code> ,返回它节点值的 <strong>前序</strong><em> </em>遍历。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;" />
<pre>
<strong>输入:</strong>root = [1,null,2,3]
<strong>输出:</strong>[1,2,3]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>root = []
<strong>输出:</strong>[]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>root = [1]
<strong>输出:</strong>[1]
</pre>
<p><strong>示例 4:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;" />
<pre>
<strong>输入:</strong>root = [1,2]
<strong>输出:</strong>[1,2]
</pre>
<p><strong>示例 5:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;" />
<pre>
<strong>输入:</strong>root = [1,null,2]
<strong>输出:</strong>[1,2]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li>树中节点数目在范围 <code>[0, 100]</code></li>
<li><code>-100 <= Node.val <= 100</code></li>
</ul>
<p> </p>
<p><strong>进阶:</strong>递归算法很简单,你可以通过迭代算法完成吗?</p>
<p>给你一个目标数组 <code>target</code> 和一个整数 <code>n</code>。每次迭代,需要从  <code>list = {1,2,3..., n}</code> 中依序读取一个数字。</p>
<p>请使用下述操作来构建目标数组 <code>target</code></p>
<ul>
<li><strong>Push</strong>:从 <code>list</code> 中读取一个新元素, 并将其推入数组中。</li>
<li><strong>Pop</strong>:删除数组中的最后一个元素。</li>
<li>如果目标数组构建完成,就停止读取更多元素。</li>
</ul>
<p>题目数据保证目标数组严格递增,并且只包含 <code>1</code><code>n</code> 之间的数字。</p>
<p>请返回构建目标数组所用的操作序列。</p>
<p>题目数据保证答案是唯一的。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>target = [1,3], n = 3
<strong>输出:</strong>["Push","Push","Pop","Push"]
<strong>解释:
</strong>读取 1 并自动推入数组 -> [1]
读取 2 并自动推入数组,然后删除它 -> [1]
读取 3 并自动推入数组 -> [1,3]
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>target = [1,2,3], n = 3
<strong>输出:</strong>["Push","Push","Push"]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>target = [1,2], n = 4
<strong>输出:</strong>["Push","Push"]
<strong>解释:</strong>只需要读取前 2 个数字就可以停止。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>target = [2,3,4], n = 4
<strong>输出:</strong>["Push","Pop","Push","Push","Push"]
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= target.length <= 100</code></li>
<li><code>1 <= target[i] <= 100</code></li>
<li><code>1 <= n <= 100</code></li>
<li><code>target</code> 是严格递增的</li>
</ul>
<p>给你一个整数数组 <code>arr</code></p>
<p>现需要从数组中取三个下标 <code>i</code><code>j</code><code>k</code> ,其中 <code>(0 &lt;= i &lt; j &lt;= k &lt; arr.length)</code></p>
<p><code>a</code><code>b</code> 定义如下:</p>
<ul>
<li><code>a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]</code></li>
<li><code>b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]</code></li>
</ul>
<p>注意:<strong>^</strong> 表示 <strong>按位异或</strong> 操作。</p>
<p>请返回能够令 <code>a == b</code> 成立的三元组 (<code>i</code>, <code>j</code> , <code>k</code>) 的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [2,3,1,6,7]
<strong>输出:</strong>4
<strong>解释:</strong>满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,1,1,1,1]
<strong>输出:</strong>10
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [2,3]
<strong>输出:</strong>0
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [1,3,5,7,9]
<strong>输出:</strong>3
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [7,11,12,9,5,2,7,17,22]
<strong>输出:</strong>8
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 300</code></li>
<li><code>1 &lt;= arr[i] &lt;= 10^8</code></li>
</ul>
<p>给你一棵有&nbsp;<code>n</code>&nbsp;个节点的无向树,节点编号为&nbsp;<code>0</code>&nbsp;&nbsp;<code>n-1</code>&nbsp;,它们中有一些节点有苹果。通过树上的一条边,需要花费 1 秒钟。你从&nbsp;<strong>节点 0&nbsp;</strong>出发,请你返回最少需要多少秒,可以收集到所有苹果,并回到节点 0 。</p>
<p>无向树的边由&nbsp;<code>edges</code>&nbsp;给出,其中&nbsp;<code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>]</code>&nbsp;,表示有一条边连接&nbsp;<code>from</code>&nbsp;&nbsp;<code>to<sub>i</sub></code> 。除此以外,还有一个布尔数组&nbsp;<code>hasApple</code> ,其中&nbsp;<code>hasApple[i] = true</code>&nbsp;代表节点&nbsp;<code>i</code>&nbsp;有一个苹果,否则,节点&nbsp;<code>i</code>&nbsp;没有苹果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/10/min_time_collect_apple_1.png" style="height: 212px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,true,true,false]
<strong>输出:</strong>8
<strong>解释:</strong>上图展示了给定的树,其中红色节点表示有苹果。一个能收集到所有苹果的最优方案由绿色箭头表示。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/10/min_time_collect_apple_2.png" style="height: 212px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,false,true,false]
<strong>输出:</strong>6
<strong>解释:</strong>上图展示了给定的树,其中红色节点表示有苹果。一个能收集到所有苹果的最优方案由绿色箭头表示。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,false,false,false,false,false]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li><code>edges.length == n-1</code></li>
<li><code>edges[i].length == 2</code></li>
<li><code>0 &lt;= from<sub>i</sub>, to<sub>i</sub> &lt;= n-1</code></li>
<li><code>from<sub>i</sub>&nbsp;&lt; to<sub>i</sub></code></li>
<li><code>hasApple.length == n</code></li>
</ul>
<p>给你一个&nbsp;<code>rows x cols</code>&nbsp;大小的矩形披萨和一个整数 <code>k</code>&nbsp;,矩形包含两种字符:&nbsp;<code>&#39;A&#39;</code> (表示苹果)和&nbsp;<code>&#39;.&#39;</code>&nbsp;(表示空白格子)。你需要切披萨 <code>k-1</code> 次,得到&nbsp;<code>k</code>&nbsp;块披萨并送给别人。</p>
<p>切披萨的每一刀,先要选择是向垂直还是水平方向切,再在矩形的边界上选一个切的位置,将披萨一分为二。如果垂直地切披萨,那么需要把左边的部分送给一个人,如果水平地切,那么需要把上面的部分送给一个人。在切完最后一刀后,需要把剩下来的一块送给最后一个人。</p>
<p>请你返回确保每一块披萨包含&nbsp;<strong>至少</strong>&nbsp;一个苹果的切披萨方案数。由于答案可能是个很大的数字,请你返回它对 10^9 + 7 取余的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/10/ways_to_cut_apple_1.png" style="height: 378px; width: 500px;"></strong></p>
<pre><strong>输入:</strong>pizza = [&quot;A..&quot;,&quot;AAA&quot;,&quot;...&quot;], k = 3
<strong>输出:</strong>3
<strong>解释:</strong>上图展示了三种切披萨的方案。注意每一块披萨都至少包含一个苹果。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>pizza = [&quot;A..&quot;,&quot;AA.&quot;,&quot;...&quot;], k = 3
<strong>输出:</strong>1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>pizza = [&quot;A..&quot;,&quot;A..&quot;,&quot;...&quot;], k = 1
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= rows, cols &lt;= 50</code></li>
<li><code>rows ==&nbsp;pizza.length</code></li>
<li><code>cols ==&nbsp;pizza[i].length</code></li>
<li><code>1 &lt;= k &lt;= 10</code></li>
<li><code>pizza</code>&nbsp;只包含字符&nbsp;<code>&#39;A&#39;</code>&nbsp;&nbsp;<code>&#39;.&#39;</code>&nbsp;</li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>&nbsp;,字符串的「能量」定义为:只包含一种字符的最长非空子字符串的长度。</p>
<p>请你返回字符串的能量。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;leetcode&quot;
<strong>输出:</strong>2
<strong>解释:</strong>子字符串 &quot;ee&quot; 长度为 2 ,只包含字符 &#39;e&#39;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;abbcccddddeeeeedcba&quot;
<strong>输出:</strong>5
<strong>解释:</strong>子字符串 &quot;eeeee&quot; 长度为 5 ,只包含字符 &#39;e&#39;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;triplepillooooow&quot;
<strong>输出:</strong>5
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;hooraaaaaaaaaaay&quot;
<strong>输出:</strong>11
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>s = &quot;tourist&quot;
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 500</code></li>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
</ul>
<p>给你一个整数&nbsp;<code>n</code>&nbsp;,请你返回所有 0 到 1 之间(不包括 0 和 1)满足分母小于等于&nbsp;&nbsp;<code>n</code>&nbsp;<strong>最简&nbsp;</strong>分数&nbsp;。分数可以以 <strong>任意&nbsp;</strong>顺序返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 2
<strong>输出:</strong>[&quot;1/2&quot;]
<strong>解释:</strong>&quot;1/2&quot; 是唯一一个分母小于等于 2 的最简分数。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 3
<strong>输出:</strong>[&quot;1/2&quot;,&quot;1/3&quot;,&quot;2/3&quot;]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 4
<strong>输出:</strong>[&quot;1/2&quot;,&quot;1/3&quot;,&quot;1/4&quot;,&quot;2/3&quot;,&quot;3/4&quot;]
<strong>解释:</strong>&quot;2/4&quot; 不是最简分数,因为它可以化简为 &quot;1/2&quot;</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 1
<strong>输出:</strong>[]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 100</code></li>
</ul>
<p>给你一棵根为&nbsp;<code>root</code>&nbsp;的二叉树,请你返回二叉树中好节点的数目。</p>
<p>「好节点」X 定义为:从根到该节点 X 所经过的节点中,没有任何节点的值大于 X 的值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/16/test_sample_1.png" style="height: 156px; width: 263px;"></strong></p>
<pre><strong>输入:</strong>root = [3,1,4,3,null,1,5]
<strong>输出:</strong>4
<strong>解释:</strong>图中蓝色节点为好节点。
根节点 (3) 永远是个好节点。
节点 4 -&gt; (3,4) 是路径中的最大值。
节点 5 -&gt; (3,4,5) 是路径中的最大值。
节点 3 -&gt; (3,1,3) 是路径中的最大值。</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/16/test_sample_2.png" style="height: 161px; width: 157px;"></strong></p>
<pre><strong>输入:</strong>root = [3,3,null,4,2]
<strong>输出:</strong>3
<strong>解释:</strong>节点 2 -&gt; (3, 3, 2) 不是好节点,因为 &quot;3&quot; 比它大。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>root = [1]
<strong>输出:</strong>1
<strong>解释:</strong>根节点是好节点。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>二叉树中节点数目范围是&nbsp;<code>[1, 10^5]</code>&nbsp;</li>
<li>每个节点权值的范围是&nbsp;<code>[-10^4, 10^4]</code>&nbsp;</li>
</ul>
<p>给你一个整数数组 <code>cost</code> 和一个整数 <code>target</code> 。请你返回满足如下规则可以得到的 <strong>最大</strong> 整数:</p>
<ul>
<li>给当前结果添加一个数位(<code>i + 1</code>)的成本为 <code>cost[i]</code> (<code>cost</code> 数组下标从 0 开始)。</li>
<li>总成本必须恰好等于 <code>target</code> 。</li>
<li>添加的数位中没有数字 0 。</li>
</ul>
<p>由于答案可能会很大,请你以字符串形式返回。</p>
<p>如果按照上述要求无法得到任何整数,请你返回 "0" 。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>cost = [4,3,2,5,6,7,2,5,5], target = 9
<strong>输出:</strong>"7772"
<strong>解释:</strong>添加数位 '7' 的成本为 2 ,添加数位 '2' 的成本为 3 。所以 "7772" 的代价为 2*3+ 3*1 = 9 。 "977" 也是满足要求的数字,但 "7772" 是较大的数字。
<strong> 数字 成本</strong>
1 -> 4
2 -> 3
3 -> 2
4 -> 5
5 -> 6
6 -> 7
7 -> 2
8 -> 5
9 -> 5
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>cost = [7,6,5,5,5,6,8,7,8], target = 12
<strong>输出:</strong>"85"
<strong>解释:</strong>添加数位 '8' 的成本是 7 ,添加数位 '5' 的成本是 5 。"85" 的成本为 7 + 5 = 12 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>cost = [2,4,6,2,4,6,4,4,4], target = 5
<strong>输出:</strong>"0"
<strong>解释:</strong>总成本是 target 的条件下,无法生成任何整数。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>cost = [6,10,15,40,40,40,40,40,40], target = 47
<strong>输出:</strong>"32211"
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>cost.length == 9</code></li>
<li><code>1 <= cost[i] <= 5000</code></li>
<li><code>1 <= target <= 5000</code></li>
</ul>
<p>给你两个整数数组 <code>startTime</code>(开始时间)和 <code>endTime</code>(结束时间),并指定一个整数 <code>queryTime</code> 作为查询时间。</p>
<p>已知,第 <code>i</code> 名学生在 <code>startTime[i]</code> 时开始写作业并于 <code>endTime[i]</code> 时完成作业。</p>
<p>请返回在查询时间 <code>queryTime</code> 时正在做作业的学生人数。形式上,返回能够使 <code>queryTime</code> 处于区间 <code>[startTime[i], endTime[i]]</code>(含)的学生人数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
<strong>输出:</strong>1
<strong>解释:</strong>一共有 3 名学生。
第一名学生在时间 1 开始写作业,并于时间 3 完成作业,在时间 4 没有处于做作业的状态。
第二名学生在时间 2 开始写作业,并于时间 2 完成作业,在时间 4 没有处于做作业的状态。
第三名学生在时间 3 开始写作业,预计于时间 7 完成作业,这是是唯一一名在时间 4 时正在做作业的学生。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>startTime = [4], endTime = [4], queryTime = 4
<strong>输出:</strong>1
<strong>解释:</strong>在查询时间只有一名学生在做作业。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>startTime = [4], endTime = [4], queryTime = 5
<strong>输出:</strong>0
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
<strong>输出:</strong>0
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
<strong>输出:</strong>5
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>startTime.length == endTime.length</code></li>
<li><code>1 &lt;= startTime.length &lt;= 100</code></li>
<li><code>1 &lt;= startTime[i] &lt;= endTime[i] &lt;= 1000</code></li>
<li><code>1 &lt;=&nbsp;queryTime &lt;= 1000</code></li>
</ul>
<p>给定一个二叉树,返回它的 <em>后序&nbsp;</em>遍历。</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong> [1,null,2,3]
1
\
2
/
3
<strong>输出:</strong> [3,2,1]</pre>
<p><strong>进阶:</strong>&nbsp;递归算法很简单,你可以通过迭代算法完成吗?</p>
<p>「句子」是一个用空格分隔单词的字符串。给你一个满足下述格式的句子 <code>text</code> :</p>
<ul>
<li>句子的首字母大写</li>
<li><code>text</code> 中的每个单词都用单个空格分隔。</li>
</ul>
<p>请你重新排列 <code>text</code> 中的单词,使所有单词按其长度的升序排列。如果两个单词的长度相同,则保留其在原句子中的相对顺序。</p>
<p>请同样按上述格式返回新的句子。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>text = &quot;Leetcode is cool&quot;
<strong>输出:</strong>&quot;Is cool leetcode&quot;
<strong>解释:</strong>句子中共有 3 个单词,长度为 8 的 &quot;Leetcode&quot; ,长度为 2 的 &quot;is&quot; 以及长度为 4 的 &quot;cool&quot;
输出需要按单词的长度升序排列,新句子中的第一个单词首字母需要大写。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>text = &quot;Keep calm and code on&quot;
<strong>输出:</strong>&quot;On and keep calm code&quot;
<strong>解释:</strong>输出的排序情况如下:
&quot;On&quot; 2 个字母。
&quot;and&quot; 3 个字母。
&quot;keep&quot; 4 个字母,因为存在长度相同的其他单词,所以它们之间需要保留在原句子中的相对顺序。
&quot;calm&quot; 4 个字母。
&quot;code&quot; 4 个字母。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>text = &quot;To be or not to be&quot;
<strong>输出:</strong>&quot;To be or to be not&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>text</code> 以大写字母开头,然后包含若干小写字母以及单词间的单个空格。</li>
<li><code>1 &lt;= text.length &lt;= 10^5</code></li>
</ul>
<p>给你一个数组 <code>favoriteCompanies</code> ,其中 <code>favoriteCompanies[i]</code> 是第 <code>i</code> 名用户收藏的公司清单(<strong>下标从 0 开始</strong>)。</p>
<p>请找出不是其他任何人收藏的公司清单的子集的收藏清单,并返回该清单下标<em></em>下标需要按升序排列<em></em></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>favoriteCompanies = [[&quot;leetcode&quot;,&quot;google&quot;,&quot;facebook&quot;],[&quot;google&quot;,&quot;microsoft&quot;],[&quot;google&quot;,&quot;facebook&quot;],[&quot;google&quot;],[&quot;amazon&quot;]]
<strong>输出:</strong>[0,1,4]
<strong>解释:</strong>
favoriteCompanies[2]=[&quot;google&quot;,&quot;facebook&quot;] 是 favoriteCompanies[0]=[&quot;leetcode&quot;,&quot;google&quot;,&quot;facebook&quot;] 的子集。
favoriteCompanies[3]=[&quot;google&quot;] 是 favoriteCompanies[0]=[&quot;leetcode&quot;,&quot;google&quot;,&quot;facebook&quot;] 和 favoriteCompanies[1]=[&quot;google&quot;,&quot;microsoft&quot;] 的子集。
其余的收藏清单均不是其他任何人收藏的公司清单的子集,因此,答案为 [0,1,4] 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>favoriteCompanies = [[&quot;leetcode&quot;,&quot;google&quot;,&quot;facebook&quot;],[&quot;leetcode&quot;,&quot;amazon&quot;],[&quot;facebook&quot;,&quot;google&quot;]]
<strong>输出:</strong>[0,1]
<strong>解释:</strong>favoriteCompanies[2]=[&quot;facebook&quot;,&quot;google&quot;] 是 favoriteCompanies[0]=[&quot;leetcode&quot;,&quot;google&quot;,&quot;facebook&quot;] 的子集,因此,答案为 [0,1] 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>favoriteCompanies = [[&quot;leetcode&quot;],[&quot;google&quot;],[&quot;facebook&quot;],[&quot;amazon&quot;]]
<strong>输出:</strong>[0,1,2,3]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;favoriteCompanies.length &lt;= 100</code></li>
<li><code>1 &lt;=&nbsp;favoriteCompanies[i].length &lt;= 500</code></li>
<li><code>1 &lt;=&nbsp;favoriteCompanies[i][j].length &lt;= 20</code></li>
<li><code>favoriteCompanies[i]</code> 中的所有字符串 <strong>各不相同</strong></li>
<li>用户收藏的公司清单也 <strong>各不相同</strong> ,也就是说,即便我们按字母顺序排序每个清单, <code>favoriteCompanies[i] != favoriteCompanies[j] </code>仍然成立。</li>
<li>所有字符串仅包含小写英文字母。</li>
</ul>
<p>墙壁上挂着一个圆形的飞镖靶。现在请你蒙着眼睛向靶上投掷飞镖。</p>
<p>投掷到墙上的飞镖用二维平面上的点坐标数组表示。飞镖靶的半径为 <code>r</code></p>
<p>请返回能够落在 <strong>任意</strong> 半径为 <code>r</code> 的圆形靶内或靶上的最大飞镖数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/16/sample_1_1806.png" style="height: 159px; width: 186px;"></p>
<pre><strong>输入:</strong>points = [[-2,0],[2,0],[0,2],[0,-2]], r = 2
<strong>输出:</strong>4
<strong>解释:</strong>如果圆形的飞镖靶的圆心为 (0,0) ,半径为 2 ,所有的飞镖都落在靶上,此时落在靶上的飞镖数最大,值为 4 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/16/sample_2_1806.png" style="height: 183px; width: 224px;"></strong></p>
<pre><strong>输入:</strong>points = [[-3,0],[3,0],[2,6],[5,4],[0,9],[7,8]], r = 5
<strong>输出:</strong>5
<strong>解释:</strong>如果圆形的飞镖靶的圆心为 (0,4) ,半径为 5 ,则除了 (7,8) 之外的飞镖都落在靶上,此时落在靶上的飞镖数最大,值为 5 。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>points = [[-2,0],[2,0],[0,2],[0,-2]], r = 1
<strong>输出:</strong>1
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>points = [[1,2],[3,5],[1,-1],[2,3],[4,1],[1,3]], r = 2
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= points.length &lt;= 100</code></li>
<li><code>points[i].length == 2</code></li>
<li><code>-10^4 &lt;= points[i][0], points[i][1] &lt;= 10^4</code></li>
<li><code>1 &lt;= r &lt;= 5000</code></li>
</ul>
<p>给你一个字符串 <code>sentence</code> 作为句子并指定检索词为 <code>searchWord</code> ,其中句子由若干用 <strong>单个空格</strong> 分隔的单词组成。</p>
<p>请你检查检索词 <code>searchWord</code> 是否为句子 <code>sentence</code> 中任意单词的前缀。</p>
<ul>
<li>如果 <code>searchWord</code> 是某一个单词的前缀,则返回句子 <code>sentence</code> 中该单词所对应的下标(<strong>下标从 1 开始</strong>)。</li>
<li>如果 <code>searchWord</code> 是多个单词的前缀,则返回匹配的第一个单词的下标(<strong>最小下标</strong>)。</li>
<li>如果 <code>searchWord</code> 不是任何单词的前缀,则返回 <strong>-1 </strong></li>
</ul>
<p>字符串 <code>S</code><strong>前缀</strong><code>S</code> 的任何前导连续子字符串。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>sentence = "i love eating burger", searchWord = "burg"
<strong>输出:</strong>4
<strong>解释:</strong>"burg" 是 "burger" 的前缀,而 "burger" 是句子中第 4 个单词。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>sentence = "this problem is an easy problem", searchWord = "pro"
<strong>输出:</strong>2
<strong>解释:</strong>"pro" 是 "problem" 的前缀,而 "problem" 是句子中第 2 个也是第 6 个单词,但是应该返回最小下标 2 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>sentence = "i am tired", searchWord = "you"
<strong>输出:</strong>-1
<strong>解释:</strong>"you" 不是句子中任何单词的前缀。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>sentence = "i use triple pillow", searchWord = "pill"
<strong>输出:</strong>4
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>sentence = "hello from the other side", searchWord = "they"
<strong>输出:</strong>-1
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= sentence.length <= 100</code></li>
<li><code>1 <= searchWord.length <= 10</code></li>
<li><code>sentence</code> 由小写英文字母和空格组成。</li>
<li><code>searchWord</code> 由小写英文字母组成。</li>
<li>前缀就是紧密附着于词根的语素,中间不能插入其它成分,并且它的位置是固定的——-位于词根之前。(引用自 <a href="https://baike.baidu.com/item/%E5%89%8D%E7%BC%80" target="_blank">前缀_百度百科</a></li>
</ul>
<p>给你字符串 <code>s</code> 和整数 <code>k</code></p>
<p>请返回字符串 <code>s</code> 中长度为 <code>k</code> 的单个子字符串中可能包含的最大元音字母数。</p>
<p>英文中的 <strong>元音字母 </strong>为(<code>a</code>, <code>e</code>, <code>i</code>, <code>o</code>, <code>u</code>)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;abciiidef&quot;, k = 3
<strong>输出:</strong>3
<strong>解释:</strong>子字符串 &quot;iii&quot; 包含 3 个元音字母。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;aeiou&quot;, k = 2
<strong>输出:</strong>2
<strong>解释:</strong>任意长度为 2 的子字符串都包含 2 个元音字母。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;leetcode&quot;, k = 3
<strong>输出:</strong>2
<strong>解释:</strong>&quot;lee&quot;&quot;eet&quot;&quot;ode&quot; 都包含 2 个元音字母。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;rhythms&quot;, k = 4
<strong>输出:</strong>0
<strong>解释:</strong>字符串 s 中不含任何元音字母。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>s = &quot;tryhard&quot;, k = 4
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s</code> 由小写英文字母组成</li>
<li><code>1 &lt;= k &lt;= s.length</code></li>
</ul>
<p>给你一棵二叉树,每个节点的值为 1 到 9 。我们称二叉树中的一条路径是 「<strong>伪回文</strong>」的,当它满足:路径经过的所有节点值的排列中,存在一个回文序列。</p>
<p>请你返回从根到叶子节点的所有路径中&nbsp;<strong>伪回文&nbsp;</strong>路径的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/23/palindromic_paths_1.png" style="height: 201px; width: 300px;"></p>
<pre><strong>输入:</strong>root = [2,3,1,3,1,null,1]
<strong>输出:</strong>2
<strong>解释:</strong>上图为给定的二叉树。总共有 3 条从根到叶子的路径:红色路径 [2,3,3] ,绿色路径 [2,1,1] 和路径 [2,3,1] 。
在这些路径中,只有红色和绿色的路径是伪回文路径,因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ,绿色路径 [2,1,1] 存在回文排列 [1,2,1] 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/23/palindromic_paths_2.png" style="height: 314px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>root = [2,1,1,1,3,null,null,null,null,null,1]
<strong>输出:</strong>1
<strong>解释:</strong>上图为给定二叉树。总共有 3 条从根到叶子的路径:绿色路径 [2,1,1] ,路径 [2,1,3,1] 和路径 [2,1] 。
这些路径中只有绿色路径是伪回文路径,因为 [2,1,1] 存在回文排列 [1,2,1] 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>root = [9]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>给定二叉树的节点数目在&nbsp;<code>1</code>&nbsp;&nbsp;<code>10^5</code>&nbsp;之间。</li>
<li>节点值在&nbsp;<code>1</code>&nbsp;<code>9</code>&nbsp;之间。</li>
</ul>
<p>给你两个数组&nbsp;<code>nums1</code>&nbsp;&nbsp;<code>nums2</code>&nbsp;</p>
<p>请你返回 <code>nums1</code><code>nums2</code> 中两个长度相同的 <strong>非空</strong> 子序列的最大点积。</p>
<p>数组的非空子序列是通过删除原数组中某些元素(可能一个也不删除)后剩余数字组成的序列,但不能改变数字间相对顺序。比方说,<code>[2,3,5]</code>&nbsp;&nbsp;<code>[1,2,3,4,5]</code>&nbsp;的一个子序列而&nbsp;<code>[1,5,3]</code>&nbsp;不是。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums1 = [2,1,-2,5], nums2 = [3,0,-6]
<strong>输出:</strong>18
<strong>解释:</strong>从 nums1 中得到子序列 [2,-2] ,从 nums2 中得到子序列 [3,-6] 。
它们的点积为 (2*3 + (-2)*(-6)) = 18 。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums1 = [3,-2], nums2 = [2,-6,7]
<strong>输出:</strong>21
<strong>解释:</strong>从 nums1 中得到子序列 [3] ,从 nums2 中得到子序列 [7] 。
它们的点积为 (3*7) = 21 。</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>nums1 = [-1,-1], nums2 = [1,1]
<strong>输出:</strong>-1
<strong>解释:</strong>从 nums1 中得到子序列 [-1] ,从 nums2 中得到子序列 [1] 。
它们的点积为 -1 。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums1.length, nums2.length &lt;= 500</code></li>
<li><code>-1000 &lt;= nums1[i], nums2[i] &lt;= 100</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>点积:</strong></p>
<pre>
定义 <code><strong>a</strong>&nbsp;= [<em>a</em><sub>1</sub>,&nbsp;<em>a</em><sub>2</sub>,&hellip;,&nbsp;<em>a</em><sub><em>n</em></sub>]</code><strong> <code>b</code></strong><code>&nbsp;= [<em>b</em><sub>1</sub>,&nbsp;<em>b</em><sub>2</sub>,&hellip;,&nbsp;<em>b</em><sub><em>n</em></sub>]</code> 的点积为:
<img alt="\mathbf{a}\cdot \mathbf{b} = \sum_{i=1}^n a_ib_i = a_1b_1 + a_2b_2 + \cdots + a_nb_n " class="tex" src="http://upload.wikimedia.org/math/c/3/2/c329bf86e747d74f55ed2e17c36fd83f.png" />
这里的 <strong>&Sigma;</strong> 指示总和符号。
</pre>
<p>给你两个长度相同的整数数组&nbsp;<code>target</code>&nbsp;&nbsp;<code>arr</code>&nbsp;</p>
<p>每一步中,你可以选择&nbsp;<code>arr</code>&nbsp;的任意 <strong>非空子数组</strong>&nbsp;并将它翻转。你可以执行此过程任意次。</p>
<p>如果你能让 <code>arr</code>&nbsp;变得与 <code>target</code>&nbsp;相同,返回 True;否则,返回 False 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>target = [1,2,3,4], arr = [2,4,1,3]
<strong>输出:</strong>true
<strong>解释:</strong>你可以按照如下步骤使 arr 变成 target:
1- 翻转子数组 [2,4,1] ,arr 变成 [1,4,2,3]
2- 翻转子数组 [4,2] ,arr 变成 [1,2,4,3]
3- 翻转子数组 [4,3] ,arr 变成 [1,2,3,4]
上述方法并不是唯一的,还存在多种将 arr 变成 target 的方法。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>target = [7], arr = [7]
<strong>输出:</strong>true
<strong>解释:</strong>arr 不需要做任何翻转已经与 target 相等。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>target = [1,12], arr = [12,1]
<strong>输出:</strong>true
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>target = [3,7,9], arr = [3,7,11]
<strong>输出:</strong>false
<strong>解释:</strong>arr 没有数字 9 ,所以无论如何也无法变成 target 。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>target = [1,1,1,1,1], arr = [1,1,1,1,1]
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>target.length == arr.length</code></li>
<li><code>1 &lt;= target.length &lt;= 1000</code></li>
<li><code>1 &lt;= target[i] &lt;= 1000</code></li>
<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
</ul>
<div class="title__3Vvk">运用你所掌握的数据结构,设计和实现一个  <a href="https://baike.baidu.com/item/LRU" target="_blank">LRU (最近最少使用) 缓存机制</a></div>
<div class="original__bRMd">
<div>
<p>实现 <code>LRUCache</code> 类:</p>
<ul>
<li><code>LRUCache(int capacity)</code> 以正整数作为容量 <code>capacity</code> 初始化 LRU 缓存</li>
<li><code>int get(int key)</code> 如果关键字 <code>key</code> 存在于缓存中,则返回关键字的值,否则返回 <code>-1</code></li>
<li><code>void put(int key, int value)</code> 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。</li>
</ul>
<p> </p>
</div>
</div>
<p><strong>进阶</strong>:你是否可以在 <code>O(1)</code> 时间复杂度内完成这两种操作?</p>
<p> </p>
<p><strong>示例:</strong></p>
<pre>
<strong>输入</strong>
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
<strong>输出</strong>
[null, null, null, 1, null, -1, null, -1, 3, 4]
<strong>解释</strong>
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= capacity <= 3000</code></li>
<li><code>0 <= key <= 10000</code></li>
<li><code>0 <= value <= 10<sup>5</sup></code></li>
<li>最多调用 <code>2 * 10<sup>5</sup></code><code>get</code><code>put</code></li>
</ul>
<p>给你一个二进制字符串 <code>s</code> 和一个整数 <code>k</code> 。</p>
<p>如果所有长度为 <code>k</code> 的二进制字符串都是 <code>s</code> 的子串,请返回 <code>true</code> ,否则请返回 <code>false</code></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "00110110", k = 2
<strong>输出:</strong>true
<strong>解释:</strong>长度为 2 的二进制串包括 "00","01","10" 和 "11"。它们分别是 s 中下标为 0,1,3,2 开始的长度为 2 的子串。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "00110", k = 2
<strong>输出:</strong>true
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "0110", k = 1
<strong>输出:</strong>true
<strong>解释:</strong>长度为 1 的二进制串包括 "0" 和 "1",显然它们都是 s 的子串。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>s = "0110", k = 2
<strong>输出:</strong>false
<strong>解释:</strong>长度为 2 的二进制串 "00" 没有出现在 s 中。
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>s = "0000000001011100", k = 4
<strong>输出:</strong>false
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 5 * 10<sup>5</sup></code></li>
<li><code>s[i]</code> 不是<code>'0'</code> 就是 <code>'1'</code></li>
<li><code>1 <= k <= 20</code></li>
</ul>
<p>你总共需要上 <code>n</code>&nbsp;门课,课程编号依次为 <code>0</code>&nbsp;<code>n-1</code>&nbsp;</p>
<p>有的课会有直接的先修课程,比如如果想上课程&nbsp;0 ,你必须先上课程 1 ,那么会以 <code>[1,0]</code>&nbsp;数对的形式给出先修课程数对。</p>
<p>给你课程总数 <code>n</code>&nbsp;和一个直接先修课程数对列表&nbsp;<code>prerequisite</code> 和一个查询对列表&nbsp;<code>queries</code>&nbsp;</p>
<p>对于每个查询对 <code>queries[i]</code>&nbsp;,请判断&nbsp;<code>queries[i][0]</code>&nbsp;是否是&nbsp;<code>queries[i][1]</code>&nbsp;的先修课程。</p>
<p>请返回一个布尔值列表,列表中每个元素依次分别对应 <code>queries</code>&nbsp;每个查询对的判断结果。</p>
<p><strong>注意:</strong>如果课程&nbsp;<strong>a</strong>&nbsp;是课程&nbsp;<strong>b</strong>&nbsp;的先修课程且课程&nbsp;<strong>b</strong>&nbsp;是课程&nbsp;<strong>c</strong>&nbsp;的先修课程,那么课程&nbsp;<strong>a</strong>&nbsp;也是课程&nbsp;<strong>c</strong>&nbsp;的先修课程。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/graph.png" style="height: 300px; width: 300px;"></p>
<pre><strong>输入:</strong>n = 2, prerequisites = [[1,0]], queries = [[0,1],[1,0]]
<strong>输出:</strong>[false,true]
<strong>解释:</strong>课程 0 不是课程 1 的先修课程,但课程 1 是课程 0 的先修课程。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 2, prerequisites = [], queries = [[1,0],[0,1]]
<strong>输出:</strong>[false,false]
<strong>解释:</strong>没有先修课程对,所以每门课程之间是独立的。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/graph-1.png" style="height: 300px; width: 300px;"></p>
<pre><strong>输入:</strong>n = 3, prerequisites = [[1,2],[1,0],[2,0]], queries = [[1,0],[1,2]]
<strong>输出:</strong>[true,true]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 3, prerequisites = [[1,0],[2,0]], queries = [[0,1],[2,0]]
<strong>输出:</strong>[false,true]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 5, prerequisites = [[0,1],[1,2],[2,3],[3,4]], queries = [[0,4],[4,0],[1,3],[3,0]]
<strong>输出:</strong>[true,false,true,false]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 100</code></li>
<li><code>0 &lt;= prerequisite.length &lt;= (n * (n - 1) / 2)</code></li>
<li><code>0 &lt;= prerequisite[i][0], prerequisite[i][1] &lt; n</code></li>
<li><code>prerequisite[i][0] != prerequisite[i][1]</code></li>
<li>先修课程图中没有环。</li>
<li>先修课程图中没有重复的边。</li>
<li><code>1 &lt;= queries.length &lt;= 10^4</code></li>
<li><code>queries[i][0] != queries[i][1]</code></li>
</ul>
<p>给你一个&nbsp;<code>rows x cols</code> 的矩阵&nbsp;<code>grid</code>&nbsp;来表示一块樱桃地。 <code>grid</code>&nbsp;中每个格子的数字表示你能获得的樱桃数目。</p>
<p>你有两个机器人帮你收集樱桃,机器人 1 从左上角格子 <code>(0,0)</code> 出发,机器人 2 从右上角格子 <code>(0, cols-1)</code> 出发。</p>
<p>请你按照如下规则,返回两个机器人能收集的最多樱桃数目:</p>
<ul>
<li>从格子&nbsp;<code>(i,j)</code> 出发,机器人可以移动到格子&nbsp;<code>(i+1, j-1)</code><code>(i+1, j)</code> 或者&nbsp;<code>(i+1, j+1)</code>&nbsp;</li>
<li>当一个机器人经过某个格子时,它会把该格子内所有的樱桃都摘走,然后这个位置会变成空格子,即没有樱桃的格子。</li>
<li>当两个机器人同时到达同一个格子时,它们中只有一个可以摘到樱桃。</li>
<li>两个机器人在任意时刻都不能移动到 <code>grid</code>&nbsp;外面。</li>
<li>两个机器人最后都要到达&nbsp;<code>grid</code>&nbsp;最底下一行。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/sample_1_1802.png" style="height: 182px; width: 139px;"></strong></p>
<pre><strong>输入:</strong>grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]
<strong>输出:</strong>24
<strong>解释:</strong>机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
机器人 1 摘的樱桃数目为 (3 + 2 + 5 + 2) = 12 。
机器人 2 摘的樱桃数目为 (1 + 5 + 5 + 1) = 12 。
樱桃总数为: 12 + 12 = 24 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/sample_2_1802.png" style="height: 257px; width: 284px;"></strong></p>
<pre><strong>输入:</strong>grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]
<strong>输出:</strong>28
<strong>解释:</strong>机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
机器人 1 摘的樱桃数目为 (1 + 9 + 5 + 2) = 17 。
机器人 2 摘的樱桃数目为 (1 + 3 + 4 + 3) = 11 。
樱桃总数为: 17 + 11 = 28 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>grid = [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]]
<strong>输出:</strong>22
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>grid = [[1,1],[1,1]]
<strong>输出:</strong>4
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>rows == grid.length</code></li>
<li><code>cols == grid[i].length</code></li>
<li><code>2 &lt;= rows, cols &lt;= 70</code></li>
<li><code>0 &lt;= grid[i][j] &lt;= 100&nbsp;</code></li>
</ul>
<p>给你一个整数数组 <code>nums</code>,请你选择数组的两个不同下标 <code>i</code><code>j</code><em></em>使 <code>(nums[i]-1)*(nums[j]-1)</code> 取得最大值。</p>
<p>请你计算并返回该式的最大值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [3,4,5,2]
<strong>输出:</strong>12
<strong>解释:</strong>如果选择下标 i=1 和 j=2(下标从 0 开始),则可以获得最大值,(nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,5,4,5]
<strong>输出:</strong>16
<strong>解释:</strong>选择下标 i=1 和 j=3(下标从 0 开始),则可以获得最大值 (5-1)*(5-1) = 16 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [3,7]
<strong>输出:</strong>12
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= nums.length &lt;= 500</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^3</code></li>
</ul>
<p>矩形蛋糕的高度为 <code>h</code> 且宽度为 <code>w</code>,给你两个整数数组 <code>horizontalCuts</code><code>verticalCuts</code>,其中 <code>horizontalCuts[i]</code> 是从矩形蛋糕顶部到第&nbsp; <code>i</code> 个水平切口的距离,类似地, <code>verticalCuts[j]</code> 是从矩形蛋糕的左侧到第 <code>j</code> 个竖直切口的距离。</p>
<p>请你按数组 <em><code>horizontalCuts</code> </em><em> <code>verticalCuts</code> </em>中提供的水平和竖直位置切割后,请你找出 <strong>面积最大</strong> 的那份蛋糕,并返回其 <strong>面积</strong> 。由于答案可能是一个很大的数字,因此需要将结果对 <code>10^9 + 7</code> 取余后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/leetcode_max_area_2.png" style="height: 320px; width: 300px;"></p>
<pre><strong>输入:</strong>h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]
<strong>输出:</strong>4
<strong>解释:</strong>上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。切割蛋糕后,绿色的那份蛋糕面积最大。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/leetcode_max_area_3.png" style="height: 320px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]
<strong>输出:</strong>6
<strong>解释:</strong>上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。切割蛋糕后,绿色和黄色的两份蛋糕面积最大。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]
<strong>输出:</strong>9
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= h,&nbsp;w &lt;= 10^9</code></li>
<li><code>1 &lt;=&nbsp;horizontalCuts.length &lt;&nbsp;min(h, 10^5)</code></li>
<li><code>1 &lt;=&nbsp;verticalCuts.length &lt; min(w, 10^5)</code></li>
<li><code>1 &lt;=&nbsp;horizontalCuts[i] &lt; h</code></li>
<li><code>1 &lt;=&nbsp;verticalCuts[i] &lt; w</code></li>
<li>题目数据保证 <code>horizontalCuts</code> 中的所有元素各不相同</li>
<li>题目数据保证 <code>verticalCuts</code>&nbsp;中的所有元素各不相同</li>
</ul>
<p><code>n</code> 座城市,从 <code>0</code><code>n-1</code> 编号,其间共有 <code>n-1</code> 条路线。因此,要想在两座不同城市之间旅行只有唯一一条路线可供选择(路线网形成一颗树)。去年,交通运输部决定重新规划路线,以改变交通拥堵的状况。</p>
<p>路线用 <code>connections</code> 表示,其中 <code>connections[i] = [a, b]</code> 表示从城市 <code>a</code><code>b</code> 的一条有向路线。</p>
<p>今年,城市 0 将会举办一场大型比赛,很多游客都想前往城市 0 。</p>
<p>请你帮助重新规划路线方向,使每个城市都可以访问城市 0 。返回需要变更方向的最小路线数。</p>
<p>题目数据 <strong>保证</strong> 每个城市在重新规划路线方向后都能到达城市 0 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/sample_1_1819.png" style="height: 150px; width: 240px;"></strong></p>
<pre><strong>输入:</strong>n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
<strong>输出:</strong>3
<strong>解释:</strong>更改以红色显示的路线的方向,使每个城市都可以到达城市 0 。</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/sample_2_1819.png" style="height: 60px; width: 380px;"></strong></p>
<pre><strong>输入:</strong>n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]
<strong>输出:</strong>2
<strong>解释:</strong>更改以红色显示的路线的方向,使每个城市都可以到达城市 0 。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 3, connections = [[1,0],[2,0]]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 5 * 10^4</code></li>
<li><code>connections.length == n-1</code></li>
<li><code>connections[i].length == 2</code></li>
<li><code>0 &lt;= connections[i][0], connections[i][1] &lt;= n-1</code></li>
<li><code>connections[i][0] != connections[i][1]</code></li>
</ul>
<p>桌面上有 <code>2n</code> 个颜色不完全相同的球,球上的颜色共有 <code>k</code> 种。给你一个大小为 <code>k</code> 的整数数组 <code>balls</code> ,其中 <code>balls[i]</code> 是颜色为&nbsp;<code>i</code> 的球的数量。</p>
<p>所有的球都已经 <strong>随机打乱顺序</strong> ,前 <code>n</code> 个球放入第一个盒子,后 <code>n</code> 个球放入另一个盒子(请认真阅读示例 2 的解释部分)。</p>
<p><strong>注意:</strong>这两个盒子是不同的。例如,两个球颜色分别为 <code>a</code><code>b</code>,盒子分别为 <code>[]</code><code>()</code>,那么 <code>[a] (b)</code><code>[b] (a)</code> 这两种分配方式是不同的(请认真阅读示例 1 的解释部分)。</p>
<p>请计算「两个盒子中球的颜色数相同」的情况的概率。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>balls = [1,1]
<strong>输出:</strong>1.00000
<strong>解释:</strong>球平均分配的方式只有两种:
- 颜色为 1 的球放入第一个盒子,颜色为 2 的球放入第二个盒子
- 颜色为 2 的球放入第一个盒子,颜色为 1 的球放入第二个盒子
这两种分配,两个盒子中球的颜色数都相同。所以概率为 2/2 = 1 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>balls = [2,1,1]
<strong>输出:</strong>0.66667
<strong>解释:</strong>球的列表为 [1, 1, 2, 3]
随机打乱,得到 12 种等概率的不同打乱方案,每种方案概率为 1/12 :
[1,1 / 2,3], [1,1 / 3,2], [1,2 / 1,3], [1,2 / 3,1], [1,3 / 1,2], [1,3 / 2,1], [2,1 / 1,3], [2,1 / 3,1], [2,3 / 1,1], [3,1 / 1,2], [3,1 / 2,1], [3,2 / 1,1]
然后,我们将前两个球放入第一个盒子,后两个球放入第二个盒子。
这 12 种可能的随机打乱方式中的 8 种满足「两个盒子中球的颜色数相同」。
概率 = 8/12 = 0.66667
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>balls = [1,2,1,2]
<strong>输出:</strong>0.60000
<strong>解释:</strong>球的列表为 [1, 2, 2, 3, 4, 4]。要想显示所有 180 种随机打乱方案是很难的,但只检查「两个盒子中球的颜色数相同」的 108 种情况是比较容易的。
概率 = 108 / 180 = 0.6 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>balls = [3,2,1]
<strong>输出:</strong>0.30000
<strong>解释:</strong>球的列表为 [1, 1, 1, 2, 2, 3]。要想显示所有 60 种随机打乱方案是很难的,但只检查「两个盒子中球的颜色数相同」的 18 种情况是比较容易的。
概率 = 18 / 60 = 0.3 。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>balls = [6,6,6,6,6,6]
<strong>输出:</strong>0.90327
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= balls.length &lt;= 8</code></li>
<li><code>1 &lt;= balls[i] &lt;= 6</code></li>
<li><code>sum(balls)</code> 是偶数</li>
<li>答案与真实值误差在 <code>10^-5</code> 以内,则被视为正确答案</li>
</ul>
<p>给你一个数组 <code>nums</code> ,数组中有 <code>2n</code> 个元素,按 <code>[x<sub>1</sub>,x<sub>2</sub>,...,x<sub>n</sub>,y<sub>1</sub>,y<sub>2</sub>,...,y<sub>n</sub>]</code> 的格式排列。</p>
<p>请你将数组按 <code>[x<sub>1</sub>,y<sub>1</sub>,x<sub>2</sub>,y<sub>2</sub>,...,x<sub>n</sub>,y<sub>n</sub>]</code> 格式重新排列,返回重排后的数组。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [2,5,1,3,4,7], n = 3
<strong>输出:</strong>[2,3,5,4,1,7]
<strong>解释:</strong>由于 x<sub>1</sub>=2, x<sub>2</sub>=5, x<sub>3</sub>=1, y<sub>1</sub>=3, y<sub>2</sub>=4, y<sub>3</sub>=7 ,所以答案为 [2,3,5,4,1,7]
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3,4,4,3,2,1], n = 4
<strong>输出:</strong>[1,4,2,3,3,2,4,1]
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,2,2], n = 2
<strong>输出:</strong>[1,2,1,2]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 500</code></li>
<li><code>nums.length == 2n</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^3</code></li>
</ul>
<p>对链表进行插入排序。</p>
<p><img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif"><br>
<small>插入排序的动画演示如上。从第一个元素开始,该链表可以被认为已经部分排序(用黑色表示)。<br>
每次迭代时,从输入数据中移除一个元素(用红色表示),并原地将其插入到已排好序的链表中。</small></p>
<p>&nbsp;</p>
<p><strong>插入排序算法:</strong></p>
<ol>
<li>插入排序是迭代的,每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。</li>
<li>每次迭代中,插入排序只从输入数据中移除一个待排序的元素,找到它在序列中适当的位置,并将其插入。</li>
<li>重复直到所有输入数据插入完为止。</li>
</ol>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong> 4-&gt;2-&gt;1-&gt;3
<strong>输出:</strong> 1-&gt;2-&gt;3-&gt;4
</pre>
<p><strong>示例&nbsp;2:</strong></p>
<pre><strong>输入:</strong> -1-&gt;5-&gt;3-&gt;4-&gt;0
<strong>输出:</strong> -1-&gt;0-&gt;3-&gt;4-&gt;5
</pre>
<p>给你一个整数数组 <code>arr</code> 和一个整数 <code>k</code></p>
<p><code>m</code> 为数组的中位数,只要满足下述两个前提之一,就可以判定 <code>arr[i]</code> 的值比 <code>arr[j]</code> 的值更强:</p>
<ul>
<li>&nbsp;<code>|arr[i] - m| &gt; |arr[j]&nbsp;- m|</code></li>
<li>&nbsp;<code>|arr[i] - m| == |arr[j] - m|</code>,且 <code>arr[i] &gt; arr[j]</code></li>
</ul>
<p>请返回由数组中最强的 <code>k</code> 个值组成的列表。答案可以以 <strong>任意顺序</strong> 返回。</p>
<p><strong>中位数</strong> 是一个有序整数列表中处于中间位置的值。形式上,如果列表的长度为 <code>n</code> ,那么中位数就是该有序列表(下标从 0 开始)中位于 <code>((n - 1) / 2)</code> 的元素。</p>
<ul>
<li>例如 <code>arr =&nbsp;[6, -3, 7, 2, 11]</code><code>n = 5</code>:数组排序后得到 <code>arr = [-3, 2, 6, 7, 11]</code> ,数组的中间位置为 <code>m = ((5 - 1) / 2) = 2</code> ,中位数 <code>arr[m]</code> 的值为 <code>6</code></li>
<li>例如 <code>arr =&nbsp;[-7, 22, 17,&thinsp;3]</code><code>n = 4</code>:数组排序后得到&nbsp;<code>arr = [-7, 3, 17, 22]</code> ,数组的中间位置为&nbsp;<code>m = ((4 - 1) / 2) = 1</code> ,中位数 <code>arr[m]</code> 的值为 <code>3</code></li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4,5], k = 2
<strong>输出:</strong>[5,1]
<strong>解释:</strong>中位数为 3,按从强到弱顺序排序后,数组变为 [5,1,4,2,3]。最强的两个元素是 [5, 1]。[1, 5] 也是正确答案。
注意,尽管 |5 - 3| == |1 - 3| ,但是 5 比 1 更强,因为 5 &gt; 1 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,1,3,5,5], k = 2
<strong>输出:</strong>[5,5]
<strong>解释:</strong>中位数为 3, 按从强到弱顺序排序后,数组变为 [5,5,1,1,3]。最强的两个元素是 [5, 5]。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [6,7,11,7,6,8], k = 5
<strong>输出:</strong>[11,8,6,6,7]
<strong>解释:</strong>中位数为 7, 按从强到弱顺序排序后,数组变为 [11,8,6,6,7,7]。
[11,8,6,6,7] 的任何排列都是正确答案。</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [6,-3,7,2,11], k = 3
<strong>输出:</strong>[-3,11,2]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [-7,22,17,3], k = 2
<strong>输出:</strong>[22,17]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>-10^5 &lt;= arr[i] &lt;= 10^5</code></li>
<li><code>1 &lt;= k &lt;= arr.length</code></li>
</ul>
<p>你有一个只支持单个标签页的 <strong>浏览器</strong>&nbsp;,最开始你浏览的网页是&nbsp;<code>homepage</code>&nbsp;,你可以访问其他的网站&nbsp;<code>url</code>&nbsp;,也可以在浏览历史中后退&nbsp;<code>steps</code>&nbsp;步或前进&nbsp;<code>steps</code>&nbsp;步。</p>
<p>请你实现&nbsp;<code>BrowserHistory</code> 类:</p>
<ul>
<li><code>BrowserHistory(string homepage)</code>&nbsp;,用&nbsp;<code>homepage</code>&nbsp;初始化浏览器类。</li>
<li><code>void visit(string url)</code>&nbsp;从当前页跳转访问 <code>url</code> 对应的页面&nbsp;&nbsp;。执行此操作会把浏览历史前进的记录全部删除。</li>
<li><code>string back(int steps)</code>&nbsp;在浏览历史中后退&nbsp;<code>steps</code>&nbsp;步。如果你只能在浏览历史中后退至多&nbsp;<code>x</code> 步且&nbsp;<code>steps &gt; x</code>&nbsp;,那么你只后退&nbsp;<code>x</code>&nbsp;步。请返回后退 <strong>至多</strong> <code>steps</code>&nbsp;步以后的&nbsp;<code>url</code>&nbsp;</li>
<li><code>string forward(int steps)</code>&nbsp;在浏览历史中前进&nbsp;<code>steps</code>&nbsp;步。如果你只能在浏览历史中前进至多&nbsp;<code>x</code>&nbsp;步且&nbsp;<code>steps &gt; x</code>&nbsp;,那么你只前进 <code>x</code>&nbsp;步。请返回前进&nbsp;<strong>至多</strong>&nbsp;<code>steps</code>步以后的 <code>url</code>&nbsp;</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例:</strong></p>
<pre><strong>输入:</strong>
[&quot;BrowserHistory&quot;,&quot;visit&quot;,&quot;visit&quot;,&quot;visit&quot;,&quot;back&quot;,&quot;back&quot;,&quot;forward&quot;,&quot;visit&quot;,&quot;forward&quot;,&quot;back&quot;,&quot;back&quot;]
[[&quot;leetcode.com&quot;],[&quot;google.com&quot;],[&quot;facebook.com&quot;],[&quot;youtube.com&quot;],[1],[1],[1],[&quot;linkedin.com&quot;],[2],[2],[7]]
<strong>输出:</strong>
[null,null,null,null,&quot;facebook.com&quot;,&quot;google.com&quot;,&quot;facebook.com&quot;,null,&quot;linkedin.com&quot;,&quot;google.com&quot;,&quot;leetcode.com&quot;]
<strong>解释:</strong>
BrowserHistory browserHistory = new BrowserHistory(&quot;leetcode.com&quot;);
browserHistory.visit(&quot;google.com&quot;); // 你原本在浏览 &quot;leetcode.com&quot; 。访问 &quot;google.com&quot;
browserHistory.visit(&quot;facebook.com&quot;); // 你原本在浏览 &quot;google.com&quot; 。访问 &quot;facebook.com&quot;
browserHistory.visit(&quot;youtube.com&quot;); // 你原本在浏览 &quot;facebook.com&quot; 。访问 &quot;youtube.com&quot;
browserHistory.back(1); // 你原本在浏览 &quot;youtube.com&quot; ,后退到 &quot;facebook.com&quot; 并返回 &quot;facebook.com&quot;
browserHistory.back(1); // 你原本在浏览 &quot;facebook.com&quot; ,后退到 &quot;google.com&quot; 并返回 &quot;google.com&quot;
browserHistory.forward(1); // 你原本在浏览 &quot;google.com&quot; ,前进到 &quot;facebook.com&quot; 并返回 &quot;facebook.com&quot;
browserHistory.visit(&quot;linkedin.com&quot;); // 你原本在浏览 &quot;facebook.com&quot; 。 访问 &quot;linkedin.com&quot;
browserHistory.forward(2); // 你原本在浏览 &quot;linkedin.com&quot; ,你无法前进任何步数。
browserHistory.back(2); // 你原本在浏览 &quot;linkedin.com&quot; ,后退两步依次先到 &quot;facebook.com&quot; ,然后到 &quot;google.com&quot; ,并返回 &quot;google.com&quot;
browserHistory.back(7); // 你原本在浏览 &quot;google.com&quot;, 你只能后退一步到 &quot;leetcode.com&quot; ,并返回 &quot;leetcode.com&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= homepage.length &lt;= 20</code></li>
<li><code>1 &lt;= url.length &lt;= 20</code></li>
<li><code>1 &lt;= steps &lt;= 100</code></li>
<li><code>homepage</code>&nbsp;<code>url</code>&nbsp;都只包含&nbsp;&#39;.&#39; 或者小写英文字母。</li>
<li>最多调用&nbsp;<code>5000</code>&nbsp;&nbsp;<code>visit</code>&nbsp;<code>back</code>&nbsp;&nbsp;<code>forward</code>&nbsp;函数。</li>
</ul>
<p>在一个小城市里,有 <code>m</code> 个房子排成一排,你需要给每个房子涂上 <code>n</code> 种颜色之一(颜色编号为 <code>1</code><code>n</code> )。有的房子去年夏天已经涂过颜色了,所以这些房子不可以被重新涂色。</p>
<p>我们将连续相同颜色尽可能多的房子称为一个街区。(比方说 <code>houses = [1,2,2,3,3,2,1,1]</code> ,它包含 5 个街区 <code> [{1}, {2,2}, {3,3}, {2}, {1,1}]</code> 。)</p>
<p>给你一个数组 <code>houses</code> ,一个 <code>m * n</code> 的矩阵 <code>cost</code> 和一个整数 <code>target</code> ,其中:</p>
<ul>
<li><code>houses[i]</code>:是第 <code>i</code> 个房子的颜色,<strong>0</strong> 表示这个房子还没有被涂色。</li>
<li><code>cost[i][j]</code>:是将第 <code>i</code> 个房子涂成颜色 <code>j+1</code> 的花费。</li>
</ul>
<p>请你返回房子涂色方案的最小总花费,使得每个房子都被涂色后,恰好组成 <code>target</code> 个街区。如果没有可用的涂色方案,请返回 <strong>-1</strong> 。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
<strong>输出:</strong>9
<strong>解释:</strong>房子涂色方案为 [1,2,2,1,1]
此方案包含 target = 3 个街区,分别是 [{1}, {2,2}, {1,1}]。
涂色的总花费为 (1 + 1 + 1 + 1 + 5) = 9。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
<strong>输出:</strong>11
<strong>解释:</strong>有的房子已经被涂色了,在此基础上涂色方案为 [2,2,1,2,2]
此方案包含 target = 3 个街区,分别是 [{2,2}, {1}, {2,2}]。
给第一个和最后一个房子涂色的花费为 (10 + 1) = 11。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5
<strong>输出:</strong>5
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3
<strong>输出:</strong>-1
<strong>解释:</strong>房子已经被涂色并组成了 4 个街区,分别是 [{3},{1},{2},{3}] ,无法形成 target = 3 个街区。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>m == houses.length == cost.length</code></li>
<li><code>n == cost[i].length</code></li>
<li><code>1 <= m <= 100</code></li>
<li><code>1 <= n <= 20</code></li>
<li><code>1 <= target <= m</code></li>
<li><code>0 <= houses[i] <= n</code></li>
<li><code>1 <= cost[i][j] <= 10^4</code></li>
</ul>
<p>给你一个数组&nbsp;<code>prices</code>&nbsp;,其中&nbsp;<code>prices[i]</code>&nbsp;是商店里第&nbsp;<code>i</code>&nbsp;件商品的价格。</p>
<p>商店里正在进行促销活动,如果你要买第&nbsp;<code>i</code>&nbsp;件商品,那么你可以得到与 <code>prices[j]</code> 相等的折扣,其中&nbsp;<code>j</code>&nbsp;是满足&nbsp;<code>j &gt; i</code>&nbsp;&nbsp;<code>prices[j] &lt;= prices[i]</code>&nbsp;&nbsp;<strong>最小下标</strong>&nbsp;,如果没有满足条件的&nbsp;<code>j</code>&nbsp;,你将没有任何折扣。</p>
<p>请你返回一个数组,数组中第&nbsp;<code>i</code>&nbsp;个元素是折扣后你购买商品 <code>i</code>&nbsp;最终需要支付的价格。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>prices = [8,4,6,2,3]
<strong>输出:</strong>[4,2,4,2,3]
<strong>解释:</strong>
商品 0 的价格为 price[0]=8 ,你将得到 prices[1]=4 的折扣,所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ,你将得到 prices[3]=2 的折扣,所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ,你将得到 prices[3]=2 的折扣,所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>prices = [1,2,3,4,5]
<strong>输出:</strong>[1,2,3,4,5]
<strong>解释:</strong>在这个例子中,所有商品都没有折扣。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>prices = [10,1,1,6]
<strong>输出:</strong>[9,0,1,6]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= prices.length &lt;= 500</code></li>
<li><code>1 &lt;= prices[i] &lt;= 10^3</code></li>
</ul>
<p>请你实现一个类&nbsp;<code>SubrectangleQueries</code>&nbsp;,它的构造函数的参数是一个 <code>rows x cols</code>&nbsp;的矩形(这里用整数矩阵表示),并支持以下两种操作:</p>
<p>1.<code>&nbsp;updateSubrectangle(int row1, int col1, int row2, int col2, int newValue)</code></p>
<ul>
<li>&nbsp;<code>newValue</code>&nbsp;更新以&nbsp;<code>(row1,col1)</code>&nbsp;为左上角且以&nbsp;<code>(row2,col2)</code>&nbsp;为右下角的子矩形。</li>
</ul>
<p>2.<code>&nbsp;getValue(int row, int col)</code></p>
<ul>
<li>返回矩形中坐标 <code>(row,col)</code> 的当前值。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>
[&quot;SubrectangleQueries&quot;,&quot;getValue&quot;,&quot;updateSubrectangle&quot;,&quot;getValue&quot;,&quot;getValue&quot;,&quot;updateSubrectangle&quot;,&quot;getValue&quot;,&quot;getValue&quot;]
[[[[1,2,1],[4,3,4],[3,2,1],[1,1,1]]],[0,2],[0,0,3,2,5],[0,2],[3,1],[3,0,3,2,10],[3,1],[0,2]]
<strong>输出:</strong>
[null,1,null,5,5,null,10,5]
<strong>解释:</strong>
SubrectangleQueries subrectangleQueries = new SubrectangleQueries([[1,2,1],[4,3,4],[3,2,1],[1,1,1]]);
// 初始的 (4x3) 矩形如下:
// 1 2 1
// 4 3 4
// 3 2 1
// 1 1 1
subrectangleQueries.getValue(0, 2); // 返回 1
subrectangleQueries.updateSubrectangle(0, 0, 3, 2, 5);
// 此次更新后矩形变为:
// 5 5 5
// 5 5 5
// 5 5 5
// 5 5 5
subrectangleQueries.getValue(0, 2); // 返回 5
subrectangleQueries.getValue(3, 1); // 返回 5
subrectangleQueries.updateSubrectangle(3, 0, 3, 2, 10);
// 此次更新后矩形变为:
// 5 5 5
// 5 5 5
// 5 5 5
// 10 10 10
subrectangleQueries.getValue(3, 1); // 返回 10
subrectangleQueries.getValue(0, 2); // 返回 5
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>
[&quot;SubrectangleQueries&quot;,&quot;getValue&quot;,&quot;updateSubrectangle&quot;,&quot;getValue&quot;,&quot;getValue&quot;,&quot;updateSubrectangle&quot;,&quot;getValue&quot;]
[[[[1,1,1],[2,2,2],[3,3,3]]],[0,0],[0,0,2,2,100],[0,0],[2,2],[1,1,2,2,20],[2,2]]
<strong>输出:</strong>
[null,1,null,100,100,null,20]
<strong>解释:</strong>
SubrectangleQueries subrectangleQueries = new SubrectangleQueries([[1,1,1],[2,2,2],[3,3,3]]);
subrectangleQueries.getValue(0, 0); // 返回 1
subrectangleQueries.updateSubrectangle(0, 0, 2, 2, 100);
subrectangleQueries.getValue(0, 0); // 返回 100
subrectangleQueries.getValue(2, 2); // 返回 100
subrectangleQueries.updateSubrectangle(1, 1, 2, 2, 20);
subrectangleQueries.getValue(2, 2); // 返回 20
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>最多有&nbsp;<code>500</code>&nbsp;<code>updateSubrectangle</code>&nbsp;<code>getValue</code>&nbsp;操作。</li>
<li><code>1 &lt;= rows, cols &lt;= 100</code></li>
<li><code>rows ==&nbsp;rectangle.length</code></li>
<li><code>cols == rectangle[i].length</code></li>
<li><code>0 &lt;= row1 &lt;= row2 &lt; rows</code></li>
<li><code>0 &lt;= col1 &lt;= col2 &lt; cols</code></li>
<li><code>1 &lt;= newValue, rectangle[i][j] &lt;= 10^9</code></li>
<li><code>0 &lt;= row &lt; rows</code></li>
<li><code>0 &lt;= col &lt; cols</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code> 和一个整数值&nbsp;<code>target</code>&nbsp;</p>
<p>请你在 <code>arr</code>&nbsp;中找 <strong>两个互不重叠的子数组</strong>&nbsp;且它们的和都等于&nbsp;<code>target</code>&nbsp;。可能会有多种方案,请你返回满足要求的两个子数组长度和的 <strong>最小值</strong></p>
<p>请返回满足要求的最小长度和,如果无法找到这样的两个子数组,请返回 <strong>-1</strong>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [3,2,2,4,3], target = 3
<strong>输出:</strong>2
<strong>解释:</strong>只有两个子数组和为 3 ([3] 和 [3])。它们的长度和为 2 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [7,3,4,7], target = 7
<strong>输出:</strong>2
<strong>解释:</strong>尽管我们有 3 个互不重叠的子数组和为 7 ([7], [3,4] 和 [7]),但我们会选择第一个和第三个子数组,因为它们的长度和 2 是最小值。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [4,3,2,6,2,3,4], target = 6
<strong>输出:</strong>-1
<strong>解释:</strong>我们只有一个和为 6 的子数组。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [5,5,4,4,5], target = 3
<strong>输出:</strong>-1
<strong>解释:</strong>我们无法找到和为 3 的子数组。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [3,1,1,1,5,1,2,1], target = 3
<strong>输出:</strong>3
<strong>解释:</strong>注意子数组 [1,2] 和 [2,1] 不能成为一个方案因为它们重叠了。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
<li><code>1 &lt;= target &lt;= 10^8</code></li>
</ul>
<p>给你一个房屋数组<code>houses</code>&nbsp;和一个整数&nbsp;<code>k</code>&nbsp;,其中&nbsp;<code>houses[i]</code>&nbsp;是第 <code>i</code>&nbsp;栋房子在一条街上的位置,现需要在这条街上安排 <code>k</code>&nbsp;个邮筒。</p>
<p>请你返回每栋房子与离它最近的邮筒之间的距离的 <strong>最小 </strong>总和。</p>
<p>答案保证在 32 位有符号整数范围以内。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/13/sample_11_1816.png" style="height: 154px; width: 454px;"></p>
<pre><strong>输入:</strong>houses = [1,4,8,10,20], k = 3
<strong>输出:</strong>5
<strong>解释:</strong>将邮筒分别安放在位置 3, 9 和 20 处。
每个房子到最近邮筒的距离和为 |3-1| + |4-3| + |9-8| + |10-9| + |20-20| = 5 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/13/sample_2_1816.png" style="height: 154px; width: 433px;"></strong></p>
<pre><strong>输入:</strong>houses = [2,3,5,12,18], k = 2
<strong>输出:</strong>9
<strong>解释:</strong>将邮筒分别安放在位置 3 和 14 处。
每个房子到最近邮筒距离和为 |2-3| + |3-3| + |5-3| + |12-14| + |18-14| = 9 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>houses = [7,4,6,1], k = 1
<strong>输出:</strong>8
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>houses = [3,6,14,10], k = 4
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == houses.length</code></li>
<li><code>1 &lt;= n&nbsp;&lt;= 100</code></li>
<li><code>1 &lt;= houses[i] &lt;= 10^4</code></li>
<li><code>1 &lt;= k &lt;= n</code></li>
<li>数组&nbsp;<code>houses</code>&nbsp;中的整数互不相同。</li>
</ul>
<p>给你一个数组 <code>nums</code> 。数组「动态和」的计算公式为:<code>runningSum[i] = sum(nums[0]&hellip;nums[i])</code></p>
<p>请返回 <code>nums</code> 的动态和。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3,4]
<strong>输出:</strong>[1,3,6,10]
<strong>解释:</strong>动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,1,1,1]
<strong>输出:</strong>[1,2,3,4,5]
<strong>解释:</strong>动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [3,1,2,10,1]
<strong>输出:</strong>[3,4,6,16,17]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
<li><code>-10^6&nbsp;&lt;= nums[i] &lt;=&nbsp;10^6</code></li>
</ul>
<p>给你链表的头结点 <code>head</code> ,请将其按 <strong>升序</strong> 排列并返回 <strong>排序后的链表</strong></p>
<p><b>进阶:</b></p>
<ul>
<li>你可以在 <code>O(n log n)</code> 时间复杂度和常数级空间复杂度下,对链表进行排序吗?</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg" style="width: 302px; "/>
<pre>
<b>输入:</b>head = [4,2,1,3]
<b>输出:</b>[1,2,3,4]
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg" style="width: 402px; " />
<pre>
<b>输入:</b>head = [-1,5,3,4,0]
<b>输出:</b>[-1,0,3,4,5]
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<b>输入:</b>head = []
<b>输出:</b>[]
</pre>
<p> </p>
<p><b>提示:</b></p>
<ul>
<li>链表中节点的数目在范围 <code>[0, 5 * 10<sup>4</sup>]</code> 内</li>
<li><code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code></li>
</ul>
<p>给你一个整数数组 <code>arr</code> 和一个整数 <code>k</code> 。现需要从数组中恰好移除 <code>k</code> 个元素,请找出移除后数组中不同整数的最少数目。</p>
<ol>
</ol>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [5,5,4], k = 1
<strong>输出:</strong>1
<strong>解释:</strong>移除 1 个 4 ,数组中只剩下 5 一种整数。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [4,3,1,1,3,3,2], k = 3
<strong>输出:</strong>2
<strong>解释:</strong>先移除 4、2 ,然后再移除两个 1 中的任意 1 个或者三个 3 中的任意 1 个,最后剩下 1 和 3 两种整数。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length&nbsp;&lt;= 10^5</code></li>
<li><code>1 &lt;= arr[i] &lt;= 10^9</code></li>
<li><code>0 &lt;= k&nbsp;&lt;= arr.length</code></li>
</ul>
<p>给你一个整数数组 <code>bloomDay</code>,以及两个整数 <code>m</code><code>k</code></p>
<p>现需要制作 <code>m</code> 束花。制作花束时,需要使用花园中 <strong>相邻的 <code>k</code> 朵花</strong></p>
<p>花园中有 <code>n</code> 朵花,第 <code>i</code> 朵花会在 <code>bloomDay[i]</code> 时盛开,<strong>恰好</strong> 可以用于 <strong>一束</strong> 花中。</p>
<p>请你返回从花园中摘 <code>m</code> 束花需要等待的最少的天数。如果不能摘到 <code>m</code> 束花则返回 <strong>-1</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>bloomDay = [1,10,3,10,2], m = 3, k = 1
<strong>输出:</strong>3
<strong>解释:</strong>让我们一起观察这三天的花开过程,x 表示花开,而 _ 表示花还未开。
现在需要制作 3 束花,每束只需要 1 朵。
1 天后:[x, _, _, _, _] // 只能制作 1 束花
2 天后:[x, _, _, _, x] // 只能制作 2 束花
3 天后:[x, _, x, _, x] // 可以制作 3 束花,答案为 3
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>bloomDay = [1,10,3,10,2], m = 3, k = 2
<strong>输出:</strong>-1
<strong>解释:</strong>要制作 3 束花,每束需要 2 朵花,也就是一共需要 6 朵花。而花园中只有 5 朵花,无法满足制作要求,返回 -1 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
<strong>输出:</strong>12
<strong>解释:</strong>要制作 2 束花,每束需要 3 朵。
花园在 7 天后和 12 天后的情况如下:
7 天后:[x, x, x, x, _, x, x]
可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花,因为它们不相邻。
12 天后:[x, x, x, x, x, x, x]
显然,我们可以用不同的方式制作两束花。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>bloomDay = [1000000000,1000000000], m = 1, k = 1
<strong>输出:</strong>1000000000
<strong>解释:</strong>需要等 1000000000 天才能采到花来制作花束
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
<strong>输出:</strong>9
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>bloomDay.length == n</code></li>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li><code>1 &lt;= bloomDay[i] &lt;= 10^9</code></li>
<li><code>1 &lt;= m &lt;= 10^6</code></li>
<li><code>1 &lt;= k &lt;= n</code></li>
</ul>
<p>给你两个整数,<code>n</code><code>start</code></p>
<p>数组 <code>nums</code> 定义为:<code>nums[i] = start + 2*i</code>(下标从 0 开始)且 <code>n == nums.length</code></p>
<p>请返回 <code>nums</code> 中所有元素按位异或(<strong>XOR</strong>)后得到的结果。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 5, start = 0
<strong>输出:</strong>8
<strong>解释:</strong>数组 nums 为 [0, 2, 4, 6, 8],其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。
&quot;^&quot; 为按位异或 XOR 运算符。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 4, start = 3
<strong>输出:</strong>8
<strong>解释:</strong>数组 nums 为 [3, 5, 7, 9],其中 (3 ^ 5 ^ 7 ^ 9) = 8.</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 1, start = 7
<strong>输出:</strong>7
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 10, start = 5
<strong>输出:</strong>2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 1000</code></li>
<li><code>0 &lt;= start &lt;= 1000</code></li>
<li><code>n == nums.length</code></li>
</ul>
<p>给你一个长度为 <code>n</code> 的字符串数组 <code>names</code> 。你将会在文件系统中创建 <code>n</code> 个文件夹:在第 <code>i</code> 分钟,新建名为 <code>names[i]</code> 的文件夹。</p>
<p>由于两个文件 <strong>不能</strong> 共享相同的文件名,因此如果新建文件夹使用的文件名已经被占用,系统会以 <code>(k)</code> 的形式为新文件夹的文件名添加后缀,其中 <code>k</code> 是能保证文件名唯一的 <strong>最小正整数</strong></p>
<p>返回长度为<em> <code>n</code></em> 的字符串数组,其中 <code>ans[i]</code> 是创建第 <code>i</code> 个文件夹时系统分配给该文件夹的实际名称。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>names = [&quot;pes&quot;,&quot;fifa&quot;,&quot;gta&quot;,&quot;pes(2019)&quot;]
<strong>输出:</strong>[&quot;pes&quot;,&quot;fifa&quot;,&quot;gta&quot;,&quot;pes(2019)&quot;]
<strong>解释:</strong>文件系统将会这样创建文件名:
&quot;pes&quot; --&gt; 之前未分配,仍为 &quot;pes&quot;
&quot;fifa&quot; --&gt; 之前未分配,仍为 &quot;fifa&quot;
&quot;gta&quot; --&gt; 之前未分配,仍为 &quot;gta&quot;
&quot;pes(2019)&quot; --&gt; 之前未分配,仍为 &quot;pes(2019)&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>names = [&quot;gta&quot;,&quot;gta(1)&quot;,&quot;gta&quot;,&quot;avalon&quot;]
<strong>输出:</strong>[&quot;gta&quot;,&quot;gta(1)&quot;,&quot;gta(2)&quot;,&quot;avalon&quot;]
<strong>解释:</strong>文件系统将会这样创建文件名:
&quot;gta&quot; --&gt; 之前未分配,仍为 &quot;gta&quot;
&quot;gta(1)&quot; --&gt; 之前未分配,仍为 &quot;gta(1)&quot;
&quot;gta&quot; --&gt; 文件名被占用,系统为该名称添加后缀 (k),由于 &quot;gta(1)&quot; 也被占用,所以 k = 2 。实际创建的文件名为 &quot;gta(2)&quot;
&quot;avalon&quot; --&gt; 之前未分配,仍为 &quot;avalon&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>names = [&quot;onepiece&quot;,&quot;onepiece(1)&quot;,&quot;onepiece(2)&quot;,&quot;onepiece(3)&quot;,&quot;onepiece&quot;]
<strong>输出:</strong>[&quot;onepiece&quot;,&quot;onepiece(1)&quot;,&quot;onepiece(2)&quot;,&quot;onepiece(3)&quot;,&quot;onepiece(4)&quot;]
<strong>解释:</strong>当创建最后一个文件夹时,最小的正有效 k 为 4 ,文件名变为 &quot;onepiece(4)&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>names = [&quot;wano&quot;,&quot;wano&quot;,&quot;wano&quot;,&quot;wano&quot;]
<strong>输出:</strong>[&quot;wano&quot;,&quot;wano(1)&quot;,&quot;wano(2)&quot;,&quot;wano(3)&quot;]
<strong>解释:</strong>每次创建文件夹 &quot;wano&quot; 时,只需增加后缀中 k 的值即可。</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>names = [&quot;kaido&quot;,&quot;kaido(1)&quot;,&quot;kaido&quot;,&quot;kaido(1)&quot;]
<strong>输出:</strong>[&quot;kaido&quot;,&quot;kaido(1)&quot;,&quot;kaido(2)&quot;,&quot;kaido(1)(1)&quot;]
<strong>解释:</strong>注意,如果含后缀文件名被占用,那么系统也会按规则在名称后添加新的后缀 (k) 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= names.length &lt;= 5 * 10^4</code></li>
<li><code>1 &lt;= names[i].length &lt;= 20</code></li>
<li><code>names[i]</code> 由小写英文字母、数字和/或圆括号组成。</li>
</ul>
<p>你的国家有无数个湖泊,所有湖泊一开始都是空的。当第 <code>n</code>&nbsp;个湖泊下雨的时候,如果第 <code>n</code>&nbsp;个湖泊是空的,那么它就会装满水,否则这个湖泊会发生洪水。你的目标是避免任意一个湖泊发生洪水。</p>
<p>给你一个整数数组&nbsp;<code>rains</code>&nbsp;,其中:</p>
<ul>
<li><code>rains[i] &gt; 0</code>&nbsp;表示第 <code>i</code>&nbsp;天时,第 <code>rains[i]</code>&nbsp;个湖泊会下雨。</li>
<li><code>rains[i] == 0</code>&nbsp;表示第 <code>i</code>&nbsp;天没有湖泊会下雨,你可以选择 <strong>一个</strong>&nbsp;湖泊并 <strong>抽干</strong>&nbsp;这个湖泊的水。</li>
</ul>
<p>请返回一个数组<em>&nbsp;</em><code>ans</code>&nbsp;,满足:</p>
<ul>
<li><code>ans.length == rains.length</code></li>
<li>如果&nbsp;<code>rains[i] &gt; 0</code> ,那么<code>ans[i] == -1</code>&nbsp;</li>
<li>如果&nbsp;<code>rains[i] == 0</code>&nbsp;<code>ans[i]</code>&nbsp;是你第&nbsp;<code>i</code>&nbsp;天选择抽干的湖泊。</li>
</ul>
<p>如果有多种可行解,请返回它们中的 <strong>任意一个</strong>&nbsp;。如果没办法阻止洪水,请返回一个 <strong>空的数组</strong>&nbsp;</p>
<p>请注意,如果你选择抽干一个装满水的湖泊,它会变成一个空的湖泊。但如果你选择抽干一个空的湖泊,那么将无事发生(详情请看示例 4)。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>rains = [1,2,3,4]
<strong>输出:</strong>[-1,-1,-1,-1]
<strong>解释:</strong>第一天后,装满水的湖泊包括 [1]
第二天后,装满水的湖泊包括 [1,2]
第三天后,装满水的湖泊包括 [1,2,3]
第四天后,装满水的湖泊包括 [1,2,3,4]
没有哪一天你可以抽干任何湖泊的水,也没有湖泊会发生洪水。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>rains = [1,2,0,0,2,1]
<strong>输出:</strong>[-1,-1,2,1,-1,-1]
<strong>解释:</strong>第一天后,装满水的湖泊包括 [1]
第二天后,装满水的湖泊包括 [1,2]
第三天后,我们抽干湖泊 2 。所以剩下装满水的湖泊包括 [1]
第四天后,我们抽干湖泊 1 。所以暂时没有装满水的湖泊了。
第五天后,装满水的湖泊包括 [2]。
第六天后,装满水的湖泊包括 [1,2]。
可以看出,这个方案下不会有洪水发生。同时, [-1,-1,1,2,-1,-1] 也是另一个可行的没有洪水的方案。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>rains = [1,2,0,1,2]
<strong>输出:</strong>[]
<strong>解释:</strong>第二天后,装满水的湖泊包括 [1,2]。我们可以在第三天抽干一个湖泊的水。
但第三天后,湖泊 1 和 2 都会再次下雨,所以不管我们第三天抽干哪个湖泊的水,另一个湖泊都会发生洪水。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>rains = [69,0,0,0,69]
<strong>输出:</strong>[-1,69,1,1,-1]
<strong>解释:</strong>任何形如 [-1,69,x,y,-1], [-1,x,69,y,-1] 或者 [-1,x,y,69,-1] 都是可行的解,其中 1 &lt;= x,y &lt;= 10^9
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>rains = [10,20,20]
<strong>输出:</strong>[]
<strong>解释:</strong>由于湖泊 20 会连续下 2 天的雨,所以没有没有办法阻止洪水。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= rains.length &lt;= 10^5</code></li>
<li><code>0 &lt;= rains[i] &lt;= 10^9</code></li>
</ul>
<p>给你一个 <code>n</code>&nbsp;个点的带权无向连通图,节点编号为 <code>0</code>&nbsp;<code>n-1</code>&nbsp;,同时还有一个数组 <code>edges</code>&nbsp;,其中 <code>edges[i] = [from</code><code><sub>i</sub>, to<sub>i</sub>, weight<sub>i</sub>]</code>&nbsp;表示在&nbsp;<code>from<sub>i</sub></code>&nbsp;&nbsp;<code>to<sub>i</sub></code>&nbsp;节点之间有一条带权无向边。最小生成树&nbsp;(MST) 是给定图中边的一个子集,它连接了所有节点且没有环,而且这些边的权值和最小。</p>
<p>请你找到给定图中最小生成树的所有关键边和伪关键边。如果从图中删去某条边,会导致最小生成树的权值和增加,那么我们就说它是一条关键边。伪关键边则是可能会出现在某些最小生成树中但不会出现在所有最小生成树中的边。</p>
<p>请注意,你可以分别以任意顺序返回关键边的下标和伪关键边的下标。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/21/ex1.png" style="height: 262px; width: 259px;"></p>
<pre><strong>输入:</strong>n = 5, edges = [[0,1,1],[1,2,1],[2,3,2],[0,3,2],[0,4,3],[3,4,3],[1,4,6]]
<strong>输出:</strong>[[0,1],[2,3,4,5]]
<strong>解释:</strong>上图描述了给定图。
下图是所有的最小生成树。
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/21/msts.png" style="height: 553px; width: 540px;">
注意到第 0 条边和第 1 条边出现在了所有最小生成树中,所以它们是关键边,我们将这两个下标作为输出的第一个列表。
边 2,3,4 和 5 是所有 MST 的剩余边,所以它们是伪关键边。我们将它们作为输出的第二个列表。
</pre>
<p><strong>示例 2 :</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/21/ex2.png" style="height: 253px; width: 247px;"></p>
<pre><strong>输入:</strong>n = 4, edges = [[0,1,1],[1,2,1],[2,3,1],[0,3,1]]
<strong>输出:</strong>[[],[0,1,2,3]]
<strong>解释:</strong>可以观察到 4 条边都有相同的权值,任选它们中的 3 条可以形成一棵 MST 。所以 4 条边都是伪关键边。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 100</code></li>
<li><code>1 &lt;= edges.length &lt;= min(200, n * (n - 1) / 2)</code></li>
<li><code>edges[i].length == 3</code></li>
<li><code>0 &lt;= from<sub>i</sub> &lt; to<sub>i</sub> &lt; n</code></li>
<li><code>1 &lt;= weight<sub>i</sub>&nbsp;&lt;= 1000</code></li>
<li>所有 <code>(from<sub>i</sub>, to<sub>i</sub>)</code>&nbsp;数对都是互不相同的。</li>
</ul>
<p>给你一个数组 <code>points</code> ,其中 <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> 表示 <strong>X-Y</strong> 平面上的一个点。求最多有多少个点在同一条直线上。</p>
<p> </p>
<p><strong>示例 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/25/plane1.jpg" style="width: 300px; height: 294px;" />
<pre>
<strong>输入:</strong>points = [[1,1],[2,2],[3,3]]
<strong>输出:</strong>3
</pre>
<p><strong>示例 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/25/plane2.jpg" style="width: 300px; height: 294px;" />
<pre>
<strong>输入:</strong>points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
<strong>输出:</strong>4
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= points.length <= 300</code></li>
<li><code>points[i].length == 2</code></li>
<li><code>-10<sup>4</sup> <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>4</sup></code></li>
<li><code>points</code> 中的所有点 <strong>互不相同</strong></li>
</ul>
<p>给你一个整数数组&nbsp;<code>salary</code>&nbsp;,数组里每个数都是 <strong>唯一</strong>&nbsp;的,其中&nbsp;<code>salary[i]</code> 是第&nbsp;<code>i</code>&nbsp;个员工的工资。</p>
<p>请你返回去掉最低工资和最高工资以后,剩下员工工资的平均值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>salary = [4000,3000,1000,2000]
<strong>输出:</strong>2500.00000
<strong>解释:</strong>最低工资和最高工资分别是 1000 和 4000 。
去掉最低工资和最高工资以后的平均工资是 (2000+3000)/2= 2500
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>salary = [1000,2000,3000]
<strong>输出:</strong>2000.00000
<strong>解释:</strong>最低工资和最高工资分别是 1000 和 3000 。
去掉最低工资和最高工资以后的平均工资是 (2000)/1= 2000
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>salary = [6000,5000,4000,3000,2000,1000]
<strong>输出:</strong>3500.00000
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>salary = [8000,9000,2000,3000,6000,1000]
<strong>输出:</strong>4750.00000
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 &lt;= salary.length &lt;= 100</code></li>
<li><code>10^3&nbsp;&lt;= salary[i] &lt;= 10^6</code></li>
<li><code>salary[i]</code>&nbsp;是唯一的。</li>
<li>与真实值误差在&nbsp;<code>10^-5</code> 以内的结果都将视为正确答案。</li>
</ul>
<p>给你两个正整数&nbsp;<code>n</code>&nbsp;<code>k</code>&nbsp;</p>
<p>如果正整数 <code>i</code> 满足 <code>n % i == 0</code> ,那么我们就说正整数 <code>i</code> 是整数 <code>n</code>&nbsp;的因子。</p>
<p>考虑整数 <code>n</code>&nbsp;的所有因子,将它们 <strong>升序排列</strong>&nbsp;。请你返回第 <code>k</code>&nbsp;个因子。如果 <code>n</code>&nbsp;的因子数少于 <code>k</code>&nbsp;,请你返回 <strong>-1</strong>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>n = 12, k = 3
<strong>输出:</strong>3
<strong>解释:</strong>因子列表包括 [1, 2, 3, 4, 6, 12],第 3 个因子是 3 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>n = 7, k = 2
<strong>输出:</strong>7
<strong>解释:</strong>因子列表包括 [1, 7] ,第 2 个因子是 7 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 4, k = 4
<strong>输出:</strong>-1
<strong>解释:</strong>因子列表包括 [1, 2, 4] ,只有 3 个因子,所以我们应该返回 -1 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 1, k = 1
<strong>输出:</strong>1
<strong>解释:</strong>因子列表包括 [1] ,第 1 个因子为 1 。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 1000, k = 3
<strong>输出:</strong>4
<strong>解释:</strong>因子列表包括 [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 125, 200, 250, 500, 1000] 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= k &lt;= n &lt;= 1000</code></li>
</ul>
<p>给你一个二进制数组&nbsp;<code>nums</code>&nbsp;,你需要从中删掉一个元素。</p>
<p>请你在删掉元素的结果数组中,返回最长的且只包含 1 的非空子数组的长度。</p>
<p>如果不存在这样的子数组,请返回 0 。</p>
<p>&nbsp;</p>
<p><strong>提示 1:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,0,1]
<strong>输出:</strong>3
<strong>解释:</strong>删掉位置 2 的数后,[1,1,1] 包含 3 个 1 。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [0,1,1,1,0,1,1,0,1]
<strong>输出:</strong>5
<strong>解释:</strong>删掉位置 4 的数字后,[0,1,1,1,1,1,0,1] 的最长全 1 子数组为 [1,1,1,1,1] 。</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,1]
<strong>输出:</strong>2
<strong>解释:</strong>你必须要删除一个元素。</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,0,0,1,1,1,0,1]
<strong>输出:</strong>4
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>nums = [0,0,0]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>nums[i]</code>&nbsp;要么是&nbsp;<code>0</code>&nbsp;要么是&nbsp;<code>1</code></li>
</ul>
<p>给你一个整数&nbsp;<code>n</code>&nbsp;表示某所大学里课程的数目,编号为&nbsp;<code>1</code>&nbsp;&nbsp;<code>n</code>&nbsp;,数组&nbsp;<code>dependencies</code>&nbsp;中,&nbsp;<code>dependencies[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><sub>&nbsp;</sub>之前上。同时你还有一个整数&nbsp;<code>k</code>&nbsp;</p>
<p>在一个学期中,你 <strong>最多</strong>&nbsp;可以同时上 <code>k</code>&nbsp;门课,前提是这些课的先修课在之前的学期里已经上过了。</p>
<p>请你返回上完所有课最少需要多少个学期。题目保证一定存在一种上完所有课的方式。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/27/leetcode_parallel_courses_1.png" style="height: 164px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>n = 4, dependencies = [[2,1],[3,1],[1,4]], k = 2
<strong>输出:</strong>3
<strong>解释:</strong>上图展示了题目输入的图。在第一个学期中,我们可以上课程 2 和课程 3 。然后第二个学期上课程 1 ,第三个学期上课程 4 。
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/27/leetcode_parallel_courses_2.png" style="height: 234px; width: 300px;"></strong></p>
<pre><strong>输入:</strong>n = 5, dependencies = [[2,1],[3,1],[4,1],[1,5]], k = 2
<strong>输出:</strong>4
<strong>解释:</strong>上图展示了题目输入的图。一个最优方案是:第一学期上课程 2 和 3,第二学期上课程 4 ,第三学期上课程 1 ,第四学期上课程 5 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>n = 11, dependencies = [], k = 2
<strong>输出:</strong>6
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 15</code></li>
<li><code>1 &lt;= k &lt;= n</code></li>
<li><code>0 &lt;=&nbsp;dependencies.length &lt;= n * (n-1) / 2</code></li>
<li><code>dependencies[i].length == 2</code></li>
<li><code>1 &lt;= x<sub>i</sub>, y<sub>i</sub>&nbsp;&lt;= n</code></li>
<li><code>x<sub>i</sub> != y<sub>i</sub></code></li>
<li>所有先修关系都是不同的,也就是说&nbsp;<code>dependencies[i] != dependencies[j]</code>&nbsp;</li>
<li>题目输入的图是个有向无环图。</li>
</ul>
<p>给你一个字符串 <code>path</code>,其中 <code>path[i]</code> 的值可以是 <code>&#39;N&#39;</code><code>&#39;S&#39;</code><code>&#39;E&#39;</code> 或者 <code>&#39;W&#39;</code>,分别表示向北、向南、向东、向西移动一个单位。</p>
<p>机器人从二维平面上的原点 <code>(0, 0)</code> 处开始出发,按 <code>path</code> 所指示的路径行走。</p>
<p>如果路径在任何位置上出现相交的情况,也就是走到之前已经走过的位置,请返回 <code>True</code> ;否则,返回 <code>False</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/28/screen-shot-2020-06-10-at-123929-pm.png" style="height: 224px; width: 250px;"></p>
<pre><strong>输入:</strong>path = &quot;NES&quot;
<strong>输出:</strong>false
<strong>解释:</strong>该路径没有在任何位置相交。</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/28/screen-shot-2020-06-10-at-123843-pm.png" style="height: 212px; width: 250px;"></p>
<pre><strong>输入:</strong>path = &quot;NESWW&quot;
<strong>输出:</strong>true
<strong>解释:</strong>该路径经过原点两次。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= path.length &lt;= 10^4</code></li>
<li><code>path</code> 仅由 <code>{&#39;N&#39;, &#39;S&#39;, &#39;E&#39;, &#39;W}</code> 中的字符组成</li>
</ul>
<p>给你一个整数数组 <code>arr</code> 和一个整数 <code>k</code> ,其中数组长度是偶数,值为 <code>n</code></p>
<p>现在需要把数组恰好分成 <code>n /&nbsp;2</code> 对,以使每对数字的和都能够被 <code>k</code> 整除。</p>
<p>如果存在这样的分法,请返回 <em>True</em> ;否则,返回 <em>False</em></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4,5,10,6,7,8,9], k = 5
<strong>输出:</strong>true
<strong>解释:</strong>划分后的数字对为 (1,9),(2,8),(3,7),(4,6) 以及 (5,10) 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4,5,6], k = 7
<strong>输出:</strong>true
<strong>解释:</strong>划分后的数字对为 (1,6),(2,5) 以及 (3,4) 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4,5,6], k = 10
<strong>输出:</strong>false
<strong>解释:</strong>无法在将数组中的数字分为三对的同时满足每对数字和能够被 10 整除的条件。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [-10,10], k = 2
<strong>输出:</strong>true
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [-1,1,-2,2,-3,3,-4,4], k = 3
<strong>输出:</strong>true
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>arr.length == n</code></li>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li><code>n</code> 为偶数</li>
<li><code>-10^9 &lt;= arr[i] &lt;= 10^9</code></li>
<li><code>1 &lt;= k &lt;= 10^5</code></li>
</ul>
<p>给你一个整数数组 <code>nums</code> 和一个整数 <code>target</code></p>
<p>请你统计并返回 <code>nums</code> 中能满足其最小元素与最大元素的 <strong></strong> 小于或等于 <code>target</code><strong>非空</strong> 子序列的数目。</p>
<p>由于答案可能很大,请将结果对 10^9 + 7 取余后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [3,5,6,7], target = 9
<strong>输出:</strong>4
<strong>解释:</strong>有 4 个子序列满足该条件。
[3] -&gt; 最小元素 + 最大元素 &lt;= target (3 + 3 &lt;= 9)
[3,5] -&gt; (3 + 5 &lt;= 9)
[3,5,6] -&gt; (3 + 6 &lt;= 9)
[3,6] -&gt; (3 + 6 &lt;= 9)
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [3,3,6,8], target = 10
<strong>输出:</strong>6
<strong>解释:</strong>有 6 个子序列满足该条件。(nums 中可以有重复数字)
[3] , [3] , [3,3], [3,6] , [3,6] , [3,3,6]</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [2,3,3,4,6,7], target = 12
<strong>输出:</strong>61
<strong>解释:</strong>共有 63 个非空子序列,其中 2 个不满足条件([6,7], [7])
有效序列总数为(63 - 2 = 61)
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums = [5,2,4,1,7,6,8], target = 16
<strong>输出:</strong>127
<strong>解释:</strong>所有非空子序列都满足条件 (2^7 - 1) = 127</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums[i] &lt;= 10^6</code></li>
<li><code>1 &lt;= target &lt;= 10^6</code></li>
</ul>
<p>给你一个数组 <code>points</code> 和一个整数 <code>k</code> 。数组中每个元素都表示二维平面上的点的坐标,并按照横坐标 x 的值从小到大排序。也就是说 <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> ,并且在 <code>1 &lt;= i &lt; j &lt;= points.length</code> 的前提下, <code>x<sub>i</sub> &lt; x<sub>j</sub></code> 总成立。</p>
<p>请你找出<em> </em><code>y<sub>i</sub>&nbsp;+ y<sub>j</sub>&nbsp;+ |x<sub>i</sub>&nbsp;- x<sub>j</sub>|</code><strong>最大值</strong>,其中 <code>|x<sub>i</sub>&nbsp;- x<sub>j</sub>|&nbsp;&lt;= k</code><code>1 &lt;= i &lt; j &lt;= points.length</code></p>
<p>题目测试数据保证至少存在一对能够满足 <code>|x<sub>i</sub>&nbsp;- x<sub>j</sub>|&nbsp;&lt;= k</code> 的点。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>points = [[1,3],[2,0],[5,10],[6,-10]], k = 1
<strong>输出:</strong>4
<strong>解释:</strong>前两个点满足 |x<sub>i</sub>&nbsp;- x<sub>j</sub>| &lt;= 1 ,代入方程计算,则得到值 3 + 0 + |1 - 2| = 4 。第三个和第四个点也满足条件,得到值 10 + -10 + |5 - 6| = 1 。
没有其他满足条件的点,所以返回 4 和 1 中最大的那个。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>points = [[0,0],[3,0],[9,2]], k = 3
<strong>输出:</strong>3
<strong>解释:</strong>只有前两个点满足 |x<sub>i</sub>&nbsp;- x<sub>j</sub>| &lt;= 3 ,代入方程后得到值 0 + 0 + |0 - 3| = 3 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= points.length &lt;= 10^5</code></li>
<li><code>points[i].length == 2</code></li>
<li><code>-10^8&nbsp;&lt;= points[i][0], points[i][1] &lt;= 10^8</code></li>
<li><code>0 &lt;= k &lt;= 2 * 10^8</code></li>
<li>对于所有的<code>1 &lt;= i &lt; j &lt;= points.length</code><code>points[i][0] &lt; points[j][0]</code> 都成立。也就是说,<code>x<sub>i</sub></code> 是严格递增的。</li>
</ul>
<p>根据<a href="https://baike.baidu.com/item/%E9%80%86%E6%B3%A2%E5%85%B0%E5%BC%8F/128437" target="_blank"> 逆波兰表示法</a>,求表达式的值。</p>
<p>有效的算符包括 <code>+</code><code>-</code><code>*</code><code>/</code> 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。</p>
<p> </p>
<p><strong>说明:</strong></p>
<ul>
<li>整数除法只保留整数部分。</li>
<li>给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>tokens = ["2","1","+","3","*"]
<strong>输出:</strong>9
<strong>解释:</strong>该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>tokens = ["4","13","5","/","+"]
<strong>输出:</strong>6
<strong>解释:</strong>该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
<strong>输出:</strong>22
<strong>解释:</strong>
该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= tokens.length <= 10<sup>4</sup></code></li>
<li><code>tokens[i]</code> 要么是一个算符(<code>"+"</code><code>"-"</code><code>"*"</code><code>"/"</code>),要么是一个在范围 <code>[-200, 200]</code> 内的整数</li>
</ul>
<p> </p>
<p><strong>逆波兰表达式:</strong></p>
<p>逆波兰表达式是一种后缀表达式,所谓后缀就是指算符写在后面。</p>
<ul>
<li>平常使用的算式则是一种中缀表达式,如 <code>( 1 + 2 ) * ( 3 + 4 )</code></li>
<li>该算式的逆波兰表达式写法为 <code>( ( 1 2 + ) ( 3 4 + ) * )</code></li>
</ul>
<p>逆波兰表达式主要有以下两个优点:</p>
<ul>
<li>去掉括号后表达式无歧义,上式即便写成 <code>1 2 + 3 4 + * </code>也可以依据次序计算出正确结果。</li>
<li>适合用栈操作运算:遇到数字则入栈;遇到算符则取出栈顶两个数字进行计算,并将结果压入栈中。</li>
</ul>
<p>给你一个数字数组 <code>arr</code></p>
<p>如果一个数列中,任意相邻两项的差总等于同一个常数,那么这个数列就称为 <strong>等差数列</strong></p>
<p>如果可以重新排列数组形成等差数列,请返回 <code>true</code> ;否则,返回 <code>false</code></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [3,5,1]
<strong>输出:</strong>true
<strong>解释:</strong>对数组重新排序得到 [1,3,5] 或者 [5,3,1] ,任意相邻两项的差分别为 2 或 -2 ,可以形成等差数列。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,4]
<strong>输出:</strong>false
<strong>解释:</strong>无法通过重新排序得到等差数列。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= arr.length &lt;= 1000</code></li>
<li><code>-10^6 &lt;= arr[i] &lt;= 10^6</code></li>
</ul>
<p>有一块木板,长度为 <code>n</code><strong>单位</strong> 。一些蚂蚁在木板上移动,每只蚂蚁都以 <strong>每秒一个单位</strong> 的速度移动。其中,一部分蚂蚁向 <strong></strong> 移动,其他蚂蚁向 <strong></strong> 移动。</p>
<p>当两只向 <strong>不同</strong> 方向移动的蚂蚁在某个点相遇时,它们会同时改变移动方向并继续移动。假设更改方向不会花费任何额外时间。</p>
<p>而当蚂蚁在某一时刻 <code>t</code> 到达木板的一端时,它立即从木板上掉下来。</p>
<p>给你一个整数 <code>n</code> 和两个整数数组 <code>left</code> 以及 <code>right</code> 。两个数组分别标识向左或者向右移动的蚂蚁在 <code>t = 0</code> 时的位置。请你返回最后一只蚂蚁从木板上掉下来的时刻。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p>&nbsp;</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/06/17/ants.jpg" style="height: 610px; width: 450px;"></p>
<pre><strong>输入:</strong>n = 4, left = [4,3], right = [0,1]
<strong>输出:</strong>4
<strong>解释:</strong>如上图所示:
-下标 0 处的蚂蚁命名为 A 并向右移动。
-下标 1 处的蚂蚁命名为 B 并向右移动。
-下标 3 处的蚂蚁命名为 C 并向左移动。
-下标 4 处的蚂蚁命名为 D 并向左移动。
请注意,蚂蚁在木板上的最后时刻是 t = 4 秒,之后蚂蚁立即从木板上掉下来。(也就是说在 t = 4.0000000001 时,木板上没有蚂蚁)。</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/06/17/ants2.jpg" style="height: 101px; width: 639px;"></p>
<pre><strong>输入:</strong>n = 7, left = [], right = [0,1,2,3,4,5,6,7]
<strong>输出:</strong>7
<strong>解释:</strong>所有蚂蚁都向右移动,下标为 0 的蚂蚁需要 7 秒才能从木板上掉落。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/06/17/ants3.jpg" style="height: 100px; width: 639px;"></p>
<pre><strong>输入:</strong>n = 7, left = [0,1,2,3,4,5,6,7], right = []
<strong>输出:</strong>7
<strong>解释:</strong>所有蚂蚁都向左移动,下标为 7 的蚂蚁需要 7 秒才能从木板上掉落。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 9, left = [5], right = [4]
<strong>输出:</strong>5
<strong>解释:</strong>t = 1 秒时,两只蚂蚁将回到初始位置,但移动方向与之前相反。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 6, left = [6], right = [0]
<strong>输出:</strong>6
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^4</code></li>
<li><code>0 &lt;= left.length &lt;= n + 1</code></li>
<li><code>0 &lt;= left[i] &lt;= n</code></li>
<li><code>0 &lt;= right.length &lt;= n + 1</code></li>
<li><code>0 &lt;= right[i] &lt;= n</code></li>
<li><code>1 &lt;= left.length + right.length &lt;= n + 1</code></li>
<li><code>left</code><code>right</code> 中的所有值都是唯一的,并且每个值 <strong>只能出现在二者之一</strong> 中。</li>
</ul>
<p>给你一个只包含 0 和 1 的&nbsp;<code>rows * columns</code>&nbsp;矩阵&nbsp;<code>mat</code>&nbsp;,请你返回有多少个&nbsp;<strong>子矩形</strong>&nbsp;的元素全部都是 1 。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>mat = [[1,0,1],
&nbsp; [1,1,0],
&nbsp; [1,1,0]]
<strong>输出:</strong>13
<strong>解释:
</strong><strong>6</strong>&nbsp;个 1x1 的矩形。
<strong>2</strong> 个 1x2 的矩形。
<strong>3</strong> 个 2x1 的矩形。
<strong>1</strong> 个 2x2 的矩形。
<strong>1</strong> 个 3x1 的矩形。
矩形数目总共 = 6 + 2 + 3 + 1 + 1 = <strong>13</strong>&nbsp;
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>mat = [[0,1,1,0],
&nbsp; [0,1,1,1],
&nbsp; [1,1,1,0]]
<strong>输出:</strong>24
<strong>解释:</strong>
<strong>8</strong> 个 1x1 的子矩形。
<strong>5</strong> 个 1x2 的子矩形。
<strong>2</strong> 个 1x3 的子矩形。
<strong>4</strong> 个 2x1 的子矩形。
<strong>2</strong> 个 2x2 的子矩形。
<strong>2</strong> 个 3x1 的子矩形。
<strong>1</strong> 个 3x2 的子矩形。
矩形数目总共 = 8 + 5 + 2 + 4 + 2 + 2 + 1 = <strong>24</strong><strong></strong>
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>mat = [[1,1,1,1,1,1]]
<strong>输出:</strong>21
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>mat = [[1,0,1],[0,1,0],[1,0,1]]
<strong>输出:</strong>5
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= rows&nbsp;&lt;= 150</code></li>
<li><code>1 &lt;= columns&nbsp;&lt;= 150</code></li>
<li><code>0 &lt;= mat[i][j] &lt;= 1</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>num</code> 和一个整数&nbsp;<code>k</code> 。其中,<code>num</code> 表示一个很大的整数,字符串中的每个字符依次对应整数上的各个 <strong>数位</strong></p>
<p>你可以交换这个整数相邻数位的数字 <strong>最多</strong>&nbsp;<code>k</code>&nbsp;次。</p>
<p>请你返回你能得到的最小整数,并以字符串形式返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/06/17/q4_1.jpg" style="height:40px; width:500px" /></p>
<pre>
<strong>输入:</strong>num = &quot;4321&quot;, k = 4
<strong>输出:</strong>&quot;1342&quot;
<strong>解释:</strong>4321 通过 4 次交换相邻数位得到最小整数的步骤如上图所示。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>num = &quot;100&quot;, k = 1
<strong>输出:</strong>&quot;010&quot;
<strong>解释:</strong>输出可以包含前导 0 ,但输入保证不会有前导 0 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>num = &quot;36789&quot;, k = 1000
<strong>输出:</strong>&quot;36789&quot;
<strong>解释:</strong>不需要做任何交换。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>num = &quot;22&quot;, k = 22
<strong>输出:</strong>&quot;22&quot;
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>num = &quot;9438957234785635408&quot;, k = 23
<strong>输出:</strong>&quot;0345989723478563548&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= num.length &lt;= 30000</code></li>
<li><code>num</code>&nbsp;只包含&nbsp;<strong>数字</strong>&nbsp;且不含有<strong>&nbsp;前导 0&nbsp;</strong></li>
<li><code>1 &lt;= k &lt;= 10^9</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>date</code>&nbsp;,它的格式为&nbsp;<code>Day Month Year</code>&nbsp;,其中:</p>
<ul>
<li><code>Day</code>&nbsp;是集合&nbsp;<code>{&quot;1st&quot;, &quot;2nd&quot;, &quot;3rd&quot;, &quot;4th&quot;, ..., &quot;30th&quot;, &quot;31st&quot;}</code>&nbsp;中的一个元素。</li>
<li><code>Month</code>&nbsp;是集合&nbsp;<code>{&quot;Jan&quot;, &quot;Feb&quot;, &quot;Mar&quot;, &quot;Apr&quot;, &quot;May&quot;, &quot;Jun&quot;, &quot;Jul&quot;, &quot;Aug&quot;, &quot;Sep&quot;, &quot;Oct&quot;, &quot;Nov&quot;, &quot;Dec&quot;}</code>&nbsp;中的一个元素。</li>
<li><code>Year</code>&nbsp;的范围在 ​<code>[1900, 2100]</code>&nbsp;之间。</li>
</ul>
<p>请你将字符串转变为&nbsp;<code>YYYY-MM-DD</code>&nbsp;的格式,其中:</p>
<ul>
<li><code>YYYY</code>&nbsp;表示 4 位的年份。</li>
<li><code>MM</code>&nbsp;表示 2 位的月份。</li>
<li><code>DD</code>&nbsp;表示 2 位的天数。</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>date = &quot;20th Oct 2052&quot;
<strong>输出:</strong>&quot;2052-10-20&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>date = &quot;6th Jun 1933&quot;
<strong>输出:</strong>&quot;1933-06-06&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>date = &quot;26th May 1960&quot;
<strong>输出:</strong>&quot;1960-05-26&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li>给定日期保证是合法的,所以不需要处理异常输入。</li>
</ul>
<p>给你一个数组&nbsp;<code>nums</code>&nbsp;,它包含&nbsp;<code>n</code>&nbsp;个正整数。你需要计算所有非空连续子数组的和,并将它们按升序排序,得到一个新的包含&nbsp;<code>n * (n + 1) / 2</code>&nbsp;个数字的数组。</p>
<p>请你返回在新数组中下标为<em>&nbsp;</em><code>left</code>&nbsp;&nbsp;<code>right</code> <strong>(下标从 1 开始)</strong>的所有数字和(包括左右端点)。由于答案可能很大,请你将它对 10^9 + 7 取模后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,3,4], n = 4, left = 1, right = 5
<strong>输出:</strong>13
<strong>解释:</strong>所有的子数组和为 1, 3, 6, 10, 2, 5, 9, 3, 7, 4 。将它们升序排序后,我们得到新的数组 [1, 2, 3, 3, 4, 5, 6, 7, 9, 10] 。下标从 le = 1 到 ri = 5 的和为 1 + 2 + 3 + 3 + 4 = 13 。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,3,4], n = 4, left = 3, right = 4
<strong>输出:</strong>6
<strong>解释:</strong>给定数组与示例 1 一样,所以新数组为 [1, 2, 3, 3, 4, 5, 6, 7, 9, 10] 。下标从 le = 3 到 ri = 4 的和为 3 + 3 = 6 。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,2,3,4], n = 4, left = 1, right = 10
<strong>输出:</strong>50
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^3</code></li>
<li><code>nums.length == n</code></li>
<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
<li><code>1 &lt;= left &lt;= right&nbsp;&lt;= n * (n + 1) / 2</code></li>
</ul>
<p>给你一个数组&nbsp;<code>nums</code>&nbsp;,每次操作你可以选择&nbsp;<code>nums</code>&nbsp;中的任意一个元素并将它改成任意值。</p>
<p>请你返回三次操作后, <code>nums</code>&nbsp;中最大值与最小值的差的最小值。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [5,3,2,4]
<strong>输出:</strong>0
<strong>解释:</strong>将数组 [5,3,2,4] 变成 [<strong>2</strong>,<strong>2</strong>,2,<strong>2</strong>].
最大值与最小值的差为 2-2 = 0 。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,5,0,10,14]
<strong>输出:</strong>1
<strong>解释:</strong>将数组 [1,5,0,10,14] 变成 [1,<strong>1</strong>,0,<strong>1</strong>,<strong>1</strong>] 。
最大值与最小值的差为 1-0 = 1 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [6,6,0,1,1,4,6]
<strong>输出:</strong>2
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums = [1,5,6,14,15]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
<li><code>-10^9 &lt;= nums[i] &lt;= 10^9</code></li>
</ul>
<p>Alice 和 Bob 两个人轮流玩一个游戏,Alice 先手。</p>
<p>一开始,有 <code>n</code>&nbsp;个石子堆在一起。每个人轮流操作,正在操作的玩家可以从石子堆里拿走 <strong>任意</strong>&nbsp;非零 <strong>平方数</strong>&nbsp;个石子。</p>
<p>如果石子堆里没有石子了,则无法操作的玩家输掉游戏。</p>
<p>给你正整数&nbsp;<code>n</code>&nbsp;,且已知两个人都采取最优策略。如果 Alice 会赢得比赛,那么返回&nbsp;<code>True</code>&nbsp;,否则返回&nbsp;<code>False</code>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>n = 1
<strong>输出:</strong>true
<strong>解释:</strong>Alice 拿走 1 个石子并赢得胜利,因为 Bob 无法进行任何操作。</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>n = 2
<strong>输出:</strong>false
<strong>解释:</strong>Alice 只能拿走 1 个石子,然后 Bob 拿走最后一个石子并赢得胜利(2 -&gt; 1 -&gt; 0)。</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>n = 4
<strong>输出:</strong>true
<strong>解释:</strong>n 已经是一个平方数,Alice 可以一次全拿掉 4 个石子并赢得胜利(4 -&gt; 0)。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>n = 7
<strong>输出:</strong>false
<strong>解释:</strong>当 Bob 采取最优策略时,Alice 无法赢得比赛。
如果 Alice 一开始拿走 4 个石子, Bob 会拿走 1 个石子,然后 Alice 只能拿走 1 个石子,Bob 拿走最后一个石子并赢得胜利(7 -&gt; 3 -&gt; 2 -&gt; 1 -&gt; 0)。
如果 Alice 一开始拿走 1 个石子, Bob 会拿走 4 个石子,然后 Alice 只能拿走 1 个石子,Bob 拿走最后一个石子并赢得胜利(7 -&gt; 6 -&gt; 2 -&gt; 1 -&gt; 0)。</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>n = 17
<strong>输出:</strong>false
<strong>解释:</strong>如果 Bob 采取最优策略,Alice 无法赢得胜利。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
</ul>
<p>给你一个字符串 <code>s</code> ,逐个翻转字符串中的所有 <strong>单词</strong></p>
<p><strong>单词</strong> 是由非空格字符组成的字符串。<code>s</code> 中使用至少一个空格将字符串中的 <strong>单词</strong> 分隔开。</p>
<p>请你返回一个翻转 <code>s</code> 中单词顺序并用单个空格相连的字符串。</p>
<p><strong>说明:</strong></p>
<ul>
<li>输入字符串 <code>s</code> 可以在前面、后面或者单词间包含多余的空格。</li>
<li>翻转后单词间应当仅用一个空格分隔。</li>
<li>翻转后的字符串中不应包含额外的空格。</li>
</ul>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>s = "<code>the sky is blue</code>"
<strong>输出:</strong>"<code>blue is sky the</code>"
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>s = "  hello world  "
<strong>输出:</strong>"world hello"
<strong>解释:</strong>输入字符串可以在前面或者后面包含多余的空格,但是翻转后的字符不能包括。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>s = "a good   example"
<strong>输出:</strong>"example good a"
<strong>解释:</strong>如果两个单词间有多余的空格,将翻转后单词间的空格减少到只含一个。
</pre>
<p><strong>示例 4:</strong></p>
<pre>
<strong>输入:</strong>s = " Bob Loves Alice "
<strong>输出:</strong>"Alice Loves Bob"
</pre>
<p><strong>示例 5:</strong></p>
<pre>
<strong>输入:</strong>s = "Alice does not even like bob"
<strong>输出:</strong>"bob like even not does Alice"
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 <= s.length <= 10<sup>4</sup></code></li>
<li><code>s</code> 包含英文大小写字母、数字和空格 <code>' '</code></li>
<li><code>s</code><strong>至少存在一个</strong> 单词</li>
</ul>
<ul>
</ul>
<p> </p>
<p><strong>进阶:</strong></p>
<ul>
<li>请尝试使用 <code><em>O</em>(1)</code> 额外空间复杂度的原地解法。</li>
</ul>
<p>给你一个整数数组 <code>nums</code></p>
<p>如果一组数字 <code>(i,j)</code> 满足 <code>nums[i]</code> == <code>nums[j]</code><code>i</code> &lt; <code>j</code> ,就可以认为这是一组 <strong>好数对</strong></p>
<p>返回好数对的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3,1,1,3]
<strong>输出:</strong>4
<strong>解释:</strong>有 4 组好数对,分别是 (0,3), (0,4), (3,4), (2,5) ,下标从 0 开始
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums = [1,1,1,1]
<strong>输出:</strong>6
<strong>解释:</strong>数组中的每组数字都是好数对</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums = [1,2,3]
<strong>输出:</strong>0
</pre>
<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;= 100</code></li>
</ul>
<p>给你一个二进制字符串 <code>s</code>(仅由 &#39;0&#39;&#39;1&#39; 组成的字符串)。</p>
<p>返回所有字符都为 1 的子字符串的数目。</p>
<p>由于答案可能很大,请你将它对 10^9 + 7 取模后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;0110111&quot;
<strong>输出</strong>:9
<strong>解释:</strong>共有 9 个子字符串仅由 &#39;1&#39; 组成
&quot;1&quot; -&gt; 5 次
&quot;11&quot; -&gt; 3 次
&quot;111&quot; -&gt; 1 次</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;101&quot;
<strong>输出:</strong>2
<strong>解释:</strong>子字符串 &quot;1&quot; 在 s 中共出现 2 次
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;111111&quot;
<strong>输出:</strong>21
<strong>解释:</strong>每个子字符串都仅由 &#39;1&#39; 组成
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;000&quot;
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>s[i] == &#39;0&#39;</code><code>s[i] == &#39;1&#39;</code></li>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
</ul>
<p>给你一个由 <code>n</code> 个节点(下标从 0 开始)组成的无向加权图,该图由一个描述边的列表组成,其中 <code>edges[i] = [a, b]</code> 表示连接节点 a 和 b 的一条无向边,且该边遍历成功的概率为 <code>succProb[i]</code></p>
<p>指定两个节点分别作为起点 <code>start</code> 和终点 <code>end</code> ,请你找出从起点到终点成功概率最大的路径,并返回其成功概率。</p>
<p>如果不存在从 <code>start</code><code>end</code> 的路径,请 <strong>返回 0</strong> 。只要答案与标准答案的误差不超过 <strong>1e-5 </strong>,就会被视作正确答案。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex1.png" style="height: 186px; width: 187px;"></strong></p>
<pre><strong>输入:</strong>n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
<strong>输出:</strong>0.25000
<strong>解释:</strong>从起点到终点有两条路径,其中一条的成功概率为 0.2 ,而另一条为 0.5 * 0.5 = 0.25
</pre>
<p><strong>示例 2:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex2.png" style="height: 186px; width: 189px;"></strong></p>
<pre><strong>输入:</strong>n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
<strong>输出:</strong>0.30000
</pre>
<p><strong>示例 3:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/1558_ex3.png" style="height: 191px; width: 215px;"></strong></p>
<pre><strong>输入:</strong>n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
<strong>输出:</strong>0.00000
<strong>解释:</strong>节点 0 和 节点 2 之间不存在路径
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 10^4</code></li>
<li><code>0 &lt;= start, end &lt; n</code></li>
<li><code>start != end</code></li>
<li><code>0 &lt;= a, b &lt; n</code></li>
<li><code>a != b</code></li>
<li><code>0 &lt;= succProb.length == edges.length &lt;= 2*10^4</code></li>
<li><code>0 &lt;= succProb[i] &lt;= 1</code></li>
<li>每两个节点之间最多有一条边</li>
</ul>
<p>一家快递公司希望在新城市建立新的服务中心。公司统计了该城市所有客户在二维地图上的坐标,并希望能够以此为依据为新的服务中心选址:使服务中心 <strong>到所有客户的欧几里得距离的总和最小</strong></p>
<p>给你一个数组 <code>positions</code> ,其中 <code>positions[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> 表示第 <code>i</code> 个客户在二维地图上的位置,返回到所有客户的 <strong>欧几里得距离的最小总和 。</strong></p>
<p>换句话说,请你为服务中心选址,该位置的坐标 <code>[x<sub>centre</sub>, y<sub>centre</sub>]</code> 需要使下面的公式取到最小值:</p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/q4_edited.jpg"></p>
<p>与真实值误差在 <code>10^-5</code> 之内的答案将被视作正确答案。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/q4_e1.jpg" style="height: 362px; width: 377px;"></p>
<pre><strong>输入:</strong>positions = [[0,1],[1,0],[1,2],[2,1]]
<strong>输出:</strong>4.00000
<strong>解释:</strong>如图所示,你可以选 [x<sub>centre</sub>, y<sub>centre</sub>] = [1, 1] 作为新中心的位置,这样一来到每个客户的距离就都是 1,所有距离之和为 4 ,这也是可以找到的最小值。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/12/q4_e3.jpg" style="height: 419px; width: 419px;"></p>
<pre><strong>输入:</strong>positions = [[1,1],[3,3]]
<strong>输出:</strong>2.82843
<strong>解释:</strong>欧几里得距离可能的最小总和为 sqrt(2) + sqrt(2) = 2.82843
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>positions = [[1,1]]
<strong>输出:</strong>0.00000
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>positions = [[1,1],[0,0],[2,0]]
<strong>输出:</strong>2.73205
<strong>解释:</strong>乍一看,你可能会将中心定在 [1, 0] 并期待能够得到最小总和,但是如果选址在 [1, 0] 距离总和为 3
如果将位置选在 [1.0, 0.5773502711] ,距离总和将会变为 2.73205
当心精度问题!
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>positions = [[0,1],[3,2],[4,5],[7,6],[8,9],[11,1],[2,12]]
<strong>输出:</strong>32.94036
<strong>解释:</strong>你可以用 [4.3460852395, 4.9813795505] 作为新中心的位置
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;positions.length &lt;= 50</code></li>
<li><code>positions[i].length == 2</code></li>
<li><code>0 &lt;=&nbsp;positions[i][0],&nbsp;positions[i][1] &lt;= 100</code></li>
</ul>
<p>小区便利店正在促销,用 <code>numExchange</code> 个空酒瓶可以兑换一瓶新酒。你购入了 <code>numBottles</code> 瓶酒。</p>
<p>如果喝掉了酒瓶中的酒,那么酒瓶就会变成空的。</p>
<p>请你计算 <strong>最多</strong> 能喝到多少瓶酒。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/19/sample_1_1875.png" style="height: 240px; width: 480px;"></strong></p>
<pre><strong>输入:</strong>numBottles = 9, numExchange = 3
<strong>输出:</strong>13
<strong>解释:</strong>你可以用 <code>3</code> 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 9 + 3 + 1 = 13 瓶酒。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/19/sample_2_1875.png" style="height: 240px; width: 790px;"></p>
<pre><strong>输入:</strong>numBottles = 15, numExchange = 4
<strong>输出:</strong>19
<strong>解释:</strong>你可以用 <code>4</code> 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 15 + 3 + 1 = 19 瓶酒。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>numBottles = 5, numExchange = 5
<strong>输出:</strong>6
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>numBottles = 2, numExchange = 3
<strong>输出:</strong>2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;numBottles &lt;= 100</code></li>
<li><code>2 &lt;=&nbsp;numExchange &lt;= 100</code></li>
</ul>
<p>给你一棵树(即,一个连通的无环无向图),这棵树由编号从 <code>0</code>&nbsp;<code>n - 1</code> 的 n 个节点组成,且恰好有 <code>n - 1</code><code>edges</code> 。树的根节点为节点 <code>0</code> ,树上的每一个节点都有一个标签,也就是字符串 <code>labels</code> 中的一个小写字符(编号为 <code>i</code> 的 节点的标签就是 <code>labels[i]</code></p>
<p>边数组 <code>edges</code><code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 的形式给出,该格式表示节点 <code>a<sub>i</sub></code><code>b<sub>i</sub></code> 之间存在一条边。</p>
<p>返回一个大小为 <em><code>n</code></em> 的数组,其中 <code>ans[i]</code> 表示第 <code>i</code> 个节点的子树中与节点 <code>i</code> 标签相同的节点数。</p>
<p><code>T</code> 中的子树是由 <code>T</code> 中的某个节点及其所有后代节点组成的树。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/19/q3e1.jpg" style="height: 321px; width: 441px;"></p>
<pre><strong>输入:</strong>n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = &quot;abaedcd&quot;
<strong>输出:</strong>[2,1,1,1,1,1,1]
<strong>解释:</strong>节点 0 的标签为 &#39;a&#39; ,以 &#39;a&#39; 为根节点的子树中,节点 2 的标签也是 &#39;a&#39; ,因此答案为 2 。注意树中的每个节点都是这棵子树的一部分。
节点 1 的标签为 &#39;b&#39; ,节点 1 的子树包含节点 1、4 和 5,但是节点 4、5 的标签与节点 1 不同,故而答案为 1(即,该节点本身)。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/19/q3e2.jpg" style="height: 321px; width: 381px;"></p>
<pre><strong>输入:</strong>n = 4, edges = [[0,1],[1,2],[0,3]], labels = &quot;bbbb&quot;
<strong>输出:</strong>[4,2,1,1]
<strong>解释:</strong>节点 2 的子树中只有节点 2 ,所以答案为 1 。
节点 3 的子树中只有节点 3 ,所以答案为 1 。
节点 1 的子树中包含节点 1 和 2 ,标签都是 &#39;b&#39; ,因此答案为 2 。
节点 0 的子树中包含节点 0、1、2 和 3,标签都是 &#39;b&#39;,因此答案为 4 。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/19/q3e3.jpg" style="height: 321px; width: 381px;"></p>
<pre><strong>输入:</strong>n = 5, edges = [[0,1],[0,2],[1,3],[0,4]], labels = &quot;aabab&quot;
<strong>输出:</strong>[3,2,1,1,1]
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>n = 6, edges = [[0,1],[0,2],[1,3],[3,4],[4,5]], labels = &quot;cbabaa&quot;
<strong>输出:</strong>[1,2,1,1,2,1]
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>n = 7, edges = [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]], labels = &quot;aaabaaa&quot;
<strong>输出:</strong>[6,5,4,1,3,2,1]
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= n &lt;= 10^5</code></li>
<li><code>edges.length == n - 1</code></li>
<li><code>edges[i].length == 2</code></li>
<li><code>0 &lt;= a<sub>i</sub>,&nbsp;b<sub>i</sub> &lt; n</code></li>
<li><code>a<sub>i</sub> !=&nbsp;b<sub>i</sub></code></li>
<li><code>labels.length == n</code></li>
<li><code>labels</code> 仅由小写英文字母组成</li>
</ul>
<p>给你一个只包含小写字母的字符串&nbsp;<code>s</code>&nbsp;,你需要找到 <code>s</code>&nbsp;中最多数目的非空子字符串,满足如下条件:</p>
<ol>
<li>这些字符串之间互不重叠,也就是说对于任意两个子字符串&nbsp;<code>s[i..j]</code>&nbsp;<code>s[k..l]</code>&nbsp;,要么&nbsp;<code>j &lt; k</code>&nbsp;要么&nbsp;<code>i &gt; l</code>&nbsp;</li>
<li>如果一个子字符串包含字符&nbsp;<code>char</code> ,那么&nbsp;<code>s</code>&nbsp;中所有&nbsp;<code>char</code> 字符都应该在这个子字符串中。</li>
</ol>
<p>请你找到满足上述条件的最多子字符串数目。如果有多个解法有相同的子字符串数目,请返回这些子字符串总长度最小的一个解。可以证明最小总长度解是唯一的。</p>
<p>请注意,你可以以 <strong>任意</strong>&nbsp;顺序返回最优解的子字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;adefaddaccc&quot;
<strong>输出:</strong>[&quot;e&quot;,&quot;f&quot;,&quot;ccc&quot;]
<strong>解释:</strong>下面为所有满足第二个条件的子字符串:
[
&nbsp; &quot;adefaddaccc&quot;
&nbsp; &quot;adefadda&quot;,
&nbsp; &quot;ef&quot;,
&nbsp; &quot;e&quot;,
&quot;f&quot;,
&nbsp; &quot;ccc&quot;,
]
如果我们选择第一个字符串,那么我们无法再选择其他任何字符串,所以答案为 1 。如果我们选择 &quot;adefadda&quot; ,剩下子字符串中我们只可以选择 &quot;ccc&quot; ,它是唯一不重叠的子字符串,所以答案为 2 。同时我们可以发现,选择 &quot;ef&quot; 不是最优的,因为它可以被拆分成 2 个子字符串。所以最优解是选择 [&quot;e&quot;,&quot;f&quot;,&quot;ccc&quot;] ,答案为 3 。不存在别的相同数目子字符串解。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;abbaccd&quot;
<strong>输出:</strong>[&quot;d&quot;,&quot;bb&quot;,&quot;cc&quot;]
<strong>解释:</strong>注意到解 [&quot;d&quot;,&quot;abba&quot;,&quot;cc&quot;] 答案也为 3 ,但它不是最优解,因为它的总长度更长。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
</ul>
<p>给你一个整数数组 <code>nums</code>&nbsp;,请你找出数组中乘积最大的连续子数组(该子数组中至少包含一个数字),并返回该子数组所对应的乘积。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong> [2,3,-2,4]
<strong>输出:</strong> <code>6</code>
<strong>解释:</strong>&nbsp;子数组 [2,3] 有最大乘积 6。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong> [-2,0,-1]
<strong>输出:</strong> 0
<strong>解释:</strong>&nbsp;结果不能为 2, 因为 [-2,-1] 不是子数组。</pre>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/19/change.png" style="height: 312px; width: 635px;"></p>
<p>Winston 构造了一个如上所示的函数&nbsp;<code>func</code>&nbsp;。他有一个整数数组&nbsp;<code>arr</code>&nbsp;和一个整数&nbsp;<code>target</code>&nbsp;,他想找到让&nbsp;<code>|func(arr, l, r) - target|</code>&nbsp;最小的 <code>l</code>&nbsp;<code>r</code>&nbsp;</p>
<p>请你返回&nbsp;<code>|func(arr, l, r) - target|</code>&nbsp;的最小值。</p>
<p>请注意,&nbsp;<code>func</code> 的输入参数&nbsp;<code>l</code>&nbsp;<code>r</code>&nbsp;需要满足&nbsp;<code>0 &lt;= l, r &lt; arr.length</code>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [9,12,3,7,15], target = 5
<strong>输出:</strong>2
<strong>解释:</strong>所有可能的 [l,r] 数对包括 [[0,0],[1,1],[2,2],[3,3],[4,4],[0,1],[1,2],[2,3],[3,4],[0,2],[1,3],[2,4],[0,3],[1,4],[0,4]], Winston 得到的相应结果为 [9,12,3,7,15,8,0,3,7,0,0,3,0,0,0] 。最接近 5 的值是 7 和 3,所以最小差值为 2 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1000000,1000000,1000000], target = 1
<strong>输出:</strong>999999
<strong>解释:</strong>Winston 输入函数的所有可能 [l,r] 数对得到的函数值都为 1000000 ,所以最小差值为 999999 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,4,8,16], target = 0
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>1 &lt;= arr[i] &lt;= 10^6</code></li>
<li><code>0 &lt;= target &lt;= 10^7</code></li>
</ul>
<p>给你两个非负整数&nbsp;<code>low</code>&nbsp;<code>high</code>&nbsp;。请你返回<em>&nbsp;</em><code>low</code><em> </em><em>&nbsp;</em><code>high</code><em>&nbsp;</em>之间(包括二者)奇数的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>low = 3, high = 7
<strong>输出:</strong>3
<strong>解释:</strong>3 到 7 之间奇数数字为 [3,5,7] 。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>low = 8, high = 10
<strong>输出:</strong>1
<strong>解释:</strong>8 到 10 之间奇数数字为 [9] 。</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>0 &lt;= low &lt;= high&nbsp;&lt;= 10^9</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>arr</code>&nbsp;。请你返回和为 <strong>奇数</strong>&nbsp;的子数组数目。</p>
<p>由于答案可能会很大,请你将结果对&nbsp;<code>10^9 + 7</code>&nbsp;取余后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [1,3,5]
<strong>输出:</strong>4
<strong>解释:</strong>所有的子数组为 [[1],[1,3],[1,3,5],[3],[3,5],[5]] 。
所有子数组的和为 [1,4,9,3,8,5].
奇数和包括 [1,9,3,5] ,所以答案为 4 。
</pre>
<p><strong>示例 2 :</strong></p>
<pre><strong>输入:</strong>arr = [2,4,6]
<strong>输出:</strong>0
<strong>解释:</strong>所有子数组为 [[2],[2,4],[2,4,6],[4],[4,6],[6]] 。
所有子数组和为 [2,6,12,4,10,6] 。
所有子数组和都是偶数,所以答案为 0 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4,5,6,7]
<strong>输出:</strong>16
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [100,100,99,99]
<strong>输出:</strong>4
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>arr = [7]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>1 &lt;= arr[i] &lt;= 100</code></li>
</ul>
<p>给你一个字符串&nbsp;<code>s</code>&nbsp;,一个分割被称为 「好分割」&nbsp;当它满足:将&nbsp;<code>s</code>&nbsp;分割成 2 个字符串&nbsp;<code>p</code>&nbsp;<code>q</code>&nbsp;,它们连接起来等于&nbsp;<code>s</code>&nbsp;<code>p</code>&nbsp;<code>q</code>&nbsp;中不同字符的数目相同。</p>
<p>请你返回 <code>s</code>&nbsp;中好分割的数目。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;aacaba&quot;
<strong>输出:</strong>2
<strong>解释:</strong>总共有 5 种分割字符串 <code>&quot;aacaba&quot;</code> 的方法,其中 2 种是好分割。
(&quot;a&quot;, &quot;acaba&quot;) 左边字符串和右边字符串分别包含 1 个和 3 个不同的字符。
(&quot;aa&quot;, &quot;caba&quot;) 左边字符串和右边字符串分别包含 1 个和 3 个不同的字符。
(&quot;aac&quot;, &quot;aba&quot;) 左边字符串和右边字符串分别包含 2 个和 2 个不同的字符。这是一个好分割。
(&quot;aaca&quot;, &quot;ba&quot;) 左边字符串和右边字符串分别包含 2 个和 2 个不同的字符。这是一个好分割。
(&quot;aacab&quot;, &quot;a&quot;) 左边字符串和右边字符串分别包含 3 个和 1 个不同的字符。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;abcd&quot;
<strong>输出:</strong>1
<strong>解释:</strong>好分割为将字符串分割成 (&quot;ab&quot;, &quot;cd&quot;) 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaaaa&quot;
<strong>输出:</strong>4
<strong>解释:</strong>所有分割都是好分割。</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;acbadbaada&quot;
<strong>输出:</strong>2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
</ul>
<p>给你一个整数数组&nbsp;<code>target</code>&nbsp;和一个数组&nbsp;<code>initial</code>&nbsp;<code>initial</code>&nbsp;数组与 <code>target</code>&nbsp; 数组有同样的维度,且一开始全部为 0 。</p>
<p>请你返回从 <code>initial</code>&nbsp;得到&nbsp; <code>target</code>&nbsp;的最少操作次数,每次操作需遵循以下规则:</p>
<ul>
<li><code>initial</code>&nbsp;中选择 <strong>任意</strong>&nbsp;子数组,并将子数组中每个元素增加 1 。</li>
</ul>
<p>答案保证在 32 位有符号整数以内。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>target = [1,2,3,2,1]
<strong>输出:</strong>3
<strong>解释:</strong>我们需要至少 3 次操作从 intial 数组得到 target 数组。
[0,0,0,0,0] 将下标为 0 到 4&nbsp;的元素(包含二者)加 1 。
[1,1,1,1,1] 将下标为 1 到 3 的元素(包含二者)加 1 。
[1,2,2,2,1] 将下表为 2 的元素增加 1 。
[1,2,3,2,1] 得到了目标数组。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>target = [3,1,1,2]
<strong>输出:</strong>4
<strong>解释:</strong>(initial)[0,0,0,0] -&gt; [1,1,1,1] -&gt; [1,1,1,2] -&gt; [2,1,1,2] -&gt; [3,1,1,2] (target) 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>target = [3,1,5,4,2]
<strong>输出:</strong>7
<strong>解释:</strong>(initial)[0,0,0,0,0] -&gt; [1,1,1,1,1] -&gt; [2,1,1,1,1] -&gt; [3,1,1,1,1]
-&gt; [3,1,2,2,2] -&gt; [3,1,3,3,2] -&gt; [3,1,4,4,2] -&gt; [3,1,5,4,2] (target)。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>target = [1,1,1,1]
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= target.length &lt;= 10^5</code></li>
<li><code>1 &lt;= target[i] &lt;= 10^5</code></li>
</ul>
<p>给你一个字符串 <code>s</code> 和一个 <strong>长度相同</strong> 的整数数组 <code>indices</code></p>
<p>请你重新排列字符串 <code>s</code> ,其中第 <code>i</code> 个字符需要移动到 <code>indices[i]</code> 指示的位置。</p>
<p>返回重新排列后的字符串。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/26/q1.jpg" style="height: 243px; width: 321px;"></p>
<pre><strong>输入:</strong>s = &quot;codeleet&quot;, <code>indices</code> = [4,5,6,7,0,2,1,3]
<strong>输出:</strong>&quot;leetcode&quot;
<strong>解释:</strong>如图所示,&quot;codeleet&quot; 重新排列后变为 &quot;leetcode&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;abc&quot;, <code>indices</code> = [0,1,2]
<strong>输出:</strong>&quot;abc&quot;
<strong>解释:</strong>重新排列后,每个字符都还留在原来的位置上。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;aiohn&quot;, <code>indices</code> = [3,1,4,2,0]
<strong>输出:</strong>&quot;nihao&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaiougrt&quot;, <code>indices</code> = [4,0,2,6,7,3,1,5]
<strong>输出:</strong>&quot;arigatou&quot;
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>s = &quot;art&quot;, <code>indices</code> = [1,0,2]
<strong>输出:</strong>&quot;rat&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>s.length == indices.length == n</code></li>
<li><code>1 &lt;= n &lt;= 100</code></li>
<li><code>s</code> 仅包含小写英文字母。</li>
<li><code>0 &lt;= indices[i] &lt;&nbsp;n</code></li>
<li><code>indices</code> 的所有的值都是唯一的(也就是说,<code>indices</code> 是整数 <code>0</code><code>n - 1</code> 形成的一组排列)。</li>
</ul>
<p>房间中有 <code>n</code> 个灯泡,编号从 <code>0</code><code>n-1</code> ,自左向右排成一行。最开始的时候,所有的灯泡都是 <strong></strong> 着的。</p>
<p>请你设法使得灯泡的开关状态和 <code>target</code> 描述的状态一致,其中 <code>target[i]</code> 等于 <code>1</code><code>i</code> 个灯泡是开着的,等于 <code>0</code> 意味着第 <code>i</code> 个灯是关着的。</p>
<p>有一个开关可以用于翻转灯泡的状态,翻转操作定义如下:</p>
<ul>
<li>选择当前配置下的任意一个灯泡(下标为 <code>i</code></li>
<li>翻转下标从 <code>i</code><code>n-1</code> 的每个灯泡</li>
</ul>
<p>翻转时,如果灯泡的状态为 <code>0</code> 就变为 <code>1</code>,为 <code>1</code> 就变为 <code>0</code></p>
<p>返回达成 <code>target</code> 描述的状态所需的 <strong>最少</strong> 翻转次数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>target = &quot;10111&quot;
<strong>输出:</strong>3
<strong>解释:</strong>初始配置 &quot;00000&quot;.
从第 3 个灯泡(下标为 2)开始翻转 &quot;00000&quot; -&gt; &quot;00111&quot;
从第 1 个灯泡(下标为 0)开始翻转 &quot;00111&quot; -&gt; &quot;11000&quot;
从第 2 个灯泡(下标为 1)开始翻转 &quot;11000&quot; -&gt; &quot;10111&quot;
至少需要翻转 3 次才能达成 target 描述的状态</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>target = &quot;101&quot;
<strong>输出:</strong>3
<strong>解释:</strong>&quot;000&quot; -&gt; &quot;111&quot; -&gt; &quot;100&quot; -&gt; &quot;101&quot;.
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>target = &quot;00000&quot;
<strong>输出:</strong>0
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>target = &quot;001011101&quot;
<strong>输出:</strong>5
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= target.length &lt;= 10^5</code></li>
<li><code>target[i] == &#39;0&#39;</code> 或者 <code>target[i] == &#39;1&#39;</code></li>
</ul>
<p>给你二叉树的根节点 <code>root</code> 和一个整数 <code>distance</code></p>
<p>如果二叉树中两个 <strong></strong> 节点之间的 <strong>最短路径长度</strong> 小于或者等于 <code>distance</code> ,那它们就可以构成一组 <strong>好叶子节点对</strong></p>
<p>返回树中 <strong>好叶子节点对的数量</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p>&nbsp;</p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/26/e1.jpg" style="height: 321px; width: 321px;"></p>
<pre><strong>输入:</strong>root = [1,2,3,null,4], distance = 3
<strong>输出:</strong>1
<strong>解释:</strong>树的叶节点是 3 和 4 ,它们之间的最短路径的长度是 3 。这是唯一的好叶子节点对。
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/26/e2.jpg" style="height: 321px; width: 441px;"></p>
<pre><strong>输入:</strong>root = [1,2,3,4,5,6,7], distance = 3
<strong>输出:</strong>2
<strong>解释:</strong>好叶子节点对为 [4,5] 和 [6,7] ,最短路径长度都是 2 。但是叶子节点对 [4,6] 不满足要求,因为它们之间的最短路径长度为 4 。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>root = [7,1,4,6,null,5,3,null,null,null,null,null,2], distance = 3
<strong>输出:</strong>1
<strong>解释:</strong>唯一的好叶子节点对是 [2,5] 。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>root = [100], distance = 1
<strong>输出:</strong>0
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>root = [1,1,1], distance = 2
<strong>输出:</strong>1
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>tree</code> 的节点数在 <code>[1, 2^10]</code> 范围内。</li>
<li>每个节点的值都在 <code>[1, 100]</code> 之间。</li>
<li><code>1 &lt;= distance &lt;= 10</code></li>
</ul>
已知一个长度为 <code>n</code> 的数组,预先按照升序排列,经由 <code>1</code><code>n</code><strong>旋转</strong> 后,得到输入数组。例如,原数组 <code>nums = [0,1,2,4,5,6,7]</code> 在变化后可能得到:
<ul>
<li>若旋转 <code>4</code> 次,则可以得到 <code>[4,5,6,7,0,1,2]</code></li>
<li>若旋转 <code>7</code> 次,则可以得到 <code>[0,1,2,4,5,6,7]</code></li>
</ul>
<p>注意,数组 <code>[a[0], a[1], a[2], ..., a[n-1]]</code> <strong>旋转一次</strong> 的结果为数组 <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code></p>
<p>给你一个元素值 <strong>互不相同</strong> 的数组 <code>nums</code> ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 <strong>最小元素</strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [3,4,5,1,2]
<strong>输出:</strong>1
<strong>解释:</strong>原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [4,5,6,7,0,1,2]
<strong>输出:</strong>0
<strong>解释:</strong>原数组为 [0,1,2,4,5,6,7] ,旋转 4 次得到输入数组。
</pre>
<p><strong>示例 3:</strong></p>
<pre>
<strong>输入:</strong>nums = [11,13,15,17]
<strong>输出:</strong>11
<strong>解释:</strong>原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == nums.length</code></li>
<li><code>1 <= n <= 5000</code></li>
<li><code>-5000 <= nums[i] <= 5000</code></li>
<li><code>nums</code> 中的所有整数 <strong>互不相同</strong></li>
<li><code>nums</code> 原来是一个升序排序的数组,并进行了 <code>1</code><code>n</code> 次旋转</li>
</ul>
<p><a href="https://baike.baidu.com/item/%E8%A1%8C%E7%A8%8B%E9%95%BF%E5%BA%A6%E7%BC%96%E7%A0%81/2931940?fr=aladdin" target="_blank">行程长度编码</a> 是一种常用的字符串压缩方法,它将连续的相同字符(重复 2 次或更多次)替换为字符和表示字符计数的数字(行程长度)。例如,用此方法压缩字符串 <code>&quot;aabccc&quot;</code> ,将 <code>&quot;aa&quot;</code> 替换为 <code>&quot;a2&quot;</code><code>&quot;ccc&quot;</code> 替换为` <code>&quot;c3&quot;</code> 。因此压缩后的字符串变为 <code>&quot;a2bc3&quot;</code></p>
<p>注意,本问题中,压缩时没有在单个字符后附加计数 <code>&#39;1&#39;</code></p>
<p>给你一个字符串 <code>s</code> 和一个整数 <code>k</code> 。你需要从字符串 <code>s</code> 中删除最多 <code>k</code> 个字符,以使 <code>s</code> 的行程长度编码长度最小。</p>
<p>请你返回删除最多 <code>k</code> 个字符后,<code>s</code> <strong>行程长度编码的最小长度</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaabcccd&quot;, k = 2
<strong>输出:</strong>4
<strong>解释:</strong>在不删除任何内容的情况下,压缩后的字符串是 &quot;a3bc3d&quot; ,长度为 6 。最优的方案是删除 &#39;b&#39;&#39;d&#39;,这样一来,压缩后的字符串为 &quot;a3c3&quot; ,长度是 4 。</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;aabbaa&quot;, k = 2
<strong>输出:</strong>2
<strong>解释:</strong>如果删去两个 &#39;b&#39; 字符,那么压缩后的字符串是长度为 2 的 &quot;a4&quot;
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;aaaaaaaaaaa&quot;, k = 0
<strong>输出:</strong>3
<strong>解释:</strong>由于 k 等于 0 ,不能删去任何字符。压缩后的字符串是 &quot;a11&quot; ,长度为 3 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 100</code></li>
<li><code>0 &lt;= k &lt;= s.length</code></li>
<li><code>s</code> 仅包含小写英文字母</li>
</ul>
<p>给你一个整数数组 <code>arr</code> ,以及 <code>a</code><code>b</code><code>c</code> 三个整数。请你统计其中好三元组的数量。</p>
<p>如果三元组 <code>(arr[i], arr[j], arr[k])</code> 满足下列全部条件,则认为它是一个 <strong>好三元组</strong></p>
<ul>
<li><code>0 &lt;= i &lt; j &lt; k &lt;&nbsp;arr.length</code></li>
<li><code>|arr[i] - arr[j]| &lt;= a</code></li>
<li><code>|arr[j] - arr[k]| &lt;= b</code></li>
<li><code>|arr[i] - arr[k]| &lt;= c</code></li>
</ul>
<p>其中 <code>|x|</code> 表示 <code>x</code> 的绝对值。</p>
<p>返回 <strong>好三元组的数量</strong></p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3
<strong>输出:</strong>4
<strong>解释:</strong>一共有 4 个好三元组:[(3,0,1), (3,0,1), (3,1,1), (0,1,1)] 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,1,2,2,3], a = 0, b = 0, c = 1
<strong>输出:</strong>0
<strong>解释:</strong>不存在满足所有条件的三元组。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 &lt;= arr.length &lt;= 100</code></li>
<li><code>0 &lt;= arr[i] &lt;= 1000</code></li>
<li><code>0 &lt;= a, b, c &lt;= 1000</code></li>
</ul>
<p>给你一个由 <strong>不同</strong> 整数组成的整数数组 <code>arr</code> 和一个整数 <code>k</code></p>
<p>每回合游戏都在数组的前两个元素(即 <code>arr[0]</code><code>arr[1]</code> )之间进行。比较 <code>arr[0]</code><code>arr[1]</code> 的大小,较大的整数将会取得这一回合的胜利并保留在位置 <code>0</code> ,较小的整数移至数组的末尾。当一个整数赢得 <code>k</code> 个连续回合时,游戏结束,该整数就是比赛的 <strong>赢家</strong></p>
<p>返回赢得比赛的整数。</p>
<p>题目数据 <strong>保证</strong> 游戏存在赢家。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [2,1,3,5,4,6,7], k = 2
<strong>输出:</strong>5
<strong>解释:</strong>一起看一下本场游戏每回合的情况:
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/30/q-example.png" style="height: 90px; width: 400px;">
因此将进行 4 回合比赛,其中 5 是赢家,因为它连胜 2 回合。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [3,2,1], k = 10
<strong>输出:</strong>3
<strong>解释:</strong>3 将会在前 10 个回合中连续获胜。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>arr = [1,9,8,2,3,7,6,4,5], k = 7
<strong>输出:</strong>9
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>arr = [1,11,22,33,44,55,66,77,88,99], k = 1000000000
<strong>输出:</strong>99
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>2 &lt;= arr.length &lt;= 10^5</code></li>
<li><code>1 &lt;= arr[i] &lt;= 10^6</code></li>
<li><code>arr</code> 所含的整数 <strong>各不相同</strong></li>
<li><code>1 &lt;= k &lt;= 10^9</code></li>
</ul>
<p>给你一个&nbsp;<code>n&nbsp;x n</code>&nbsp;的二进制网格&nbsp;<code>grid</code>,每一次操作中,你可以选择网格的&nbsp;<strong>相邻两行</strong>&nbsp;进行交换。</p>
<p>一个符合要求的网格需要满足主对角线以上的格子全部都是 <strong>0</strong>&nbsp;</p>
<p>请你返回使网格满足要求的最少操作次数,如果无法使网格符合要求,请你返回 <strong>-1</strong>&nbsp;</p>
<p>主对角线指的是从&nbsp;<code>(1, 1)</code>&nbsp;&nbsp;<code>(n, n)</code>&nbsp;的这些格子。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/08/02/fw.jpg" style="height: 141px; width: 750px;"></p>
<pre><strong>输入:</strong>grid = [[0,0,1],[1,1,0],[1,0,0]]
<strong>输出:</strong>3
</pre>
<p><strong>示例 2:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/08/02/e2.jpg" style="height: 270px; width: 270px;"></p>
<pre><strong>输入:</strong>grid = [[0,1,1,0],[0,1,1,0],[0,1,1,0],[0,1,1,0]]
<strong>输出:</strong>-1
<strong>解释:</strong>所有行都是一样的,交换相邻行无法使网格符合要求。
</pre>
<p><strong>示例 3:</strong></p>
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/08/02/e3.jpg" style="height: 210px; width: 210px;"></p>
<pre><strong>输入:</strong>grid = [[1,0,0],[1,1,0],[1,1,1]]
<strong>输出:</strong>0
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == grid.length</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>1 &lt;= n&nbsp;&lt;= 200</code></li>
<li><code>grid[i][j]</code>&nbsp;要么是&nbsp;<code>0</code>&nbsp;要么是&nbsp;<code>1</code>&nbsp;</li>
</ul>
<p>你有两个 <strong>有序</strong>&nbsp;且数组内元素互不相同的数组&nbsp;<code>nums1</code>&nbsp;<code>nums2</code>&nbsp;</p>
<p>一条&nbsp;<strong>合法路径</strong>&nbsp;定义如下:</p>
<ul>
<li>选择数组 nums1 或者 nums2 开始遍历(从下标 0 处开始)。</li>
<li>从左到右遍历当前数组。</li>
<li>如果你遇到了 <code>nums1</code>&nbsp;<code>nums2</code>&nbsp;中都存在的值,那么你可以切换路径到另一个数组对应数字处继续遍历(但在合法路径中重复数字只会被统计一次)。</li>
</ul>
<p>得分定义为合法路径中不同数字的和。</p>
<p>请你返回所有可能合法路径中的最大得分。</p>
<p>由于答案可能很大,请你将它对 10^9 + 7 取余后返回。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/08/02/sample_1_1893.png" style="height: 163px; width: 538px;"></strong></p>
<pre><strong>输入:</strong>nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]
<strong>输出:</strong>30
<strong>解释:</strong>合法路径包括:
[2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],(从 nums1 开始遍历)
[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10] (从 nums2 开始遍历)
最大得分为上图中的绿色路径 <strong>[2,4,6,8,10]</strong>&nbsp;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>nums1 = [1,3,5,7,9], nums2 = [3,5,100]
<strong>输出:</strong>109
<strong>解释:</strong>最大得分由路径 <strong>[1,3,5,100]</strong> 得到。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]
<strong>输出:</strong>40
<strong>解释:</strong>nums1 和 nums2 之间无相同数字。
最大得分由路径 <strong>[6,7,8,9,10]</strong> 得到。
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]
<strong>输出:</strong>61
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= nums1.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums2.length &lt;= 10^5</code></li>
<li><code>1 &lt;= nums1[i], nums2[i] &lt;= 10^7</code></li>
<li><code>nums1</code>&nbsp;<code>nums2</code>&nbsp;都是严格递增的数组。</li>
</ul>
<p>给你一个 <strong>严格升序排列</strong>&nbsp;的正整数数组 <code>arr</code>&nbsp;和一个整数&nbsp;<code>k</code>&nbsp;</p>
<p>请你找到这个数组里第&nbsp;<code>k</code>&nbsp;个缺失的正整数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>arr = [2,3,4,7,11], k = 5
<strong>输出:</strong>9
<strong>解释:</strong>缺失的正整数包括 [1,5,6,8,9,10,12,13,...] 。第 5 个缺失的正整数为 9 。
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>arr = [1,2,3,4], k = 2
<strong>输出:</strong>6
<strong>解释:</strong>缺失的正整数包括 [5,6,7,...] 。第 2 个缺失的正整数为 6 。
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= arr.length &lt;= 1000</code></li>
<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
<li><code>1 &lt;= k &lt;= 1000</code></li>
<li>对于所有&nbsp;<code>1 &lt;= i &lt; j &lt;= arr.length</code>&nbsp;<code>i</code>&nbsp;<code>j</code> 满足&nbsp;<code>arr[i] &lt; arr[j]</code>&nbsp;</li>
</ul>
<p>给你两个字符串&nbsp;<code>s</code>&nbsp;&nbsp;<code>t</code>&nbsp;,你的目标是在 <code>k</code>&nbsp;次操作以内把字符串&nbsp;<code>s</code>&nbsp;转变成&nbsp;<code>t</code>&nbsp;</p>
<p>在第 <code>i</code>&nbsp;次操作时(<code>1 &lt;= i &lt;= k</code>),你可以选择进行如下操作:</p>
<ul>
<li>选择字符串 <code>s</code>&nbsp;中满足 <code>1 &lt;= j &lt;= s.length</code>&nbsp;且之前未被选过的任意下标 <code>j</code>&nbsp;(下标从 1 开始),并将此位置的字符切换 <code>i</code>&nbsp;次。</li>
<li>不进行任何操作。</li>
</ul>
<p>切换 1 次字符的意思是用字母表中该字母的下一个字母替换它(字母表环状接起来,所以 <code>&#39;z&#39;</code>&nbsp;切换后会变成 <code>&#39;a&#39;</code>)。</p>
<p>请记住任意一个下标 <code>j</code>&nbsp;最多只能被操作&nbsp;1 次。</p>
<p>如果在不超过 <code>k</code>&nbsp;次操作内可以把字符串 <code>s</code>&nbsp;转变成 <code>t</code>&nbsp;,那么请你返回&nbsp;<code>true</code>&nbsp;,否则请你返回&nbsp;<code>false</code>&nbsp;</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;input&quot;, t = &quot;ouput&quot;, k = 9
<strong>输出:</strong>true
<strong>解释:</strong>第 6 次操作时,我们将 &#39;i&#39; 切换 6 次得到 &#39;o&#39; 。第 7 次操作时,我们将 &#39;n&#39; 切换 7 次得到 &#39;u&#39;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;abc&quot;, t = &quot;bcd&quot;, k = 10
<strong>输出:</strong>false
<strong>解释:</strong>我们需要将每个字符切换 1 次才能得到 t 。我们可以在第 1 次操作时将 &#39;a&#39; 切换成 &#39;b&#39; ,但另外 2 个字母在剩余操作中无法再转变为 t 中对应字母。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;aab&quot;, t = &quot;bbb&quot;, k = 27
<strong>输出:</strong>true
<strong>解释:</strong>第 1 次操作时,我们将第一个 &#39;a&#39; 切换 1 次得到 &#39;b&#39; 。在第 27 次操作时,我们将第二个字母 &#39;a&#39; 切换 27 次得到 &#39;b&#39;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length, t.length &lt;= 10^5</code></li>
<li><code>0 &lt;= k &lt;= 10^9</code></li>
<li><code>s</code>&nbsp;&nbsp;<code>t</code>&nbsp;只包含小写英文字母。</li>
</ul>
已知一个长度为 <code>n</code> 的数组,预先按照升序排列,经由 <code>1</code><code>n</code><strong>旋转</strong> 后,得到输入数组。例如,原数组 <code>nums = [0,1,4,4,5,6,7]</code> 在变化后可能得到:
<ul>
<li>若旋转 <code>4</code> 次,则可以得到 <code>[4,5,6,7,0,1,4]</code></li>
<li>若旋转 <code>7</code> 次,则可以得到 <code>[0,1,4,4,5,6,7]</code></li>
</ul>
<p>注意,数组 <code>[a[0], a[1], a[2], ..., a[n-1]]</code> <strong>旋转一次</strong> 的结果为数组 <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code></p>
<p>给你一个可能存在 <strong>重复</strong> 元素值的数组 <code>nums</code> ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 <strong>最小元素</strong></p>
<p> </p>
<p><strong>示例 1:</strong></p>
<pre>
<strong>输入:</strong>nums = [1,3,5]
<strong>输出:</strong>1
</pre>
<p><strong>示例 2:</strong></p>
<pre>
<strong>输入:</strong>nums = [2,2,2,0,1]
<strong>输出:</strong>0
</pre>
<p> </p>
<p><strong>提示:</strong></p>
<ul>
<li><code>n == nums.length</code></li>
<li><code>1 <= n <= 5000</code></li>
<li><code>-5000 <= nums[i] <= 5000</code></li>
<li><code>nums</code> 原来是一个升序排序的数组,并进行了 <code>1</code><code>n</code> 次旋转</li>
</ul>
<p> </p>
<p><strong>进阶:</strong></p>
<ul>
<li>这道题是 <a href="https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/description/">寻找旋转排序数组中的最小值</a> 的延伸题目。</li>
<li>允许重复会影响算法的时间复杂度吗?会如何影响,为什么?</li>
</ul>
<p>给你一个括号字符串&nbsp;<code>s</code>&nbsp;,它只包含字符&nbsp;<code>&#39;(&#39;</code>&nbsp;<code>&#39;)&#39;</code>&nbsp;。一个括号字符串被称为平衡的当它满足:</p>
<ul>
<li>任何左括号&nbsp;<code>&#39;(&#39;</code>&nbsp;必须对应两个连续的右括号&nbsp;<code>&#39;))&#39;</code>&nbsp;</li>
<li>左括号&nbsp;<code>&#39;(&#39;</code>&nbsp;必须在对应的连续两个右括号&nbsp;<code>&#39;))&#39;</code>&nbsp;之前。</li>
</ul>
<p>比方说&nbsp;<code>&quot;())&quot;</code>&nbsp;<code>&quot;())(())))&quot;</code>&nbsp;<code>&quot;(())())))&quot;</code>&nbsp;都是平衡的,&nbsp;<code>&quot;)()&quot;</code>&nbsp;<code>&quot;()))&quot;</code>&nbsp;<code>&quot;(()))&quot;</code>&nbsp;都是不平衡的。</p>
<p>你可以在任意位置插入字符 &#39;(&#39;&#39;)&#39; 使字符串平衡。</p>
<p>请你返回让 <code>s</code>&nbsp;平衡的最少插入次数。</p>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;(()))&quot;
<strong>输出:</strong>1
<strong>解释:</strong>第二个左括号有与之匹配的两个右括号,但是第一个左括号只有一个右括号。我们需要在字符串结尾额外增加一个 &#39;)&#39; 使字符串变成平衡字符串 &quot;(())))&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;())&quot;
<strong>输出:</strong>0
<strong>解释:</strong>字符串已经平衡了。
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;))())(&quot;
<strong>输出:</strong>3
<strong>解释:</strong>添加 &#39;(&#39; 去匹配最开头的 &#39;))&#39; ,然后添加 &#39;))&#39; 去匹配最后一个 &#39;(&#39;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;((((((&quot;
<strong>输出:</strong>12
<strong>解释:</strong>添加 12 个 &#39;)&#39; 得到平衡字符串。
</pre>
<p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>s = &quot;)))))))&quot;
<strong>输出:</strong>5
<strong>解释:</strong>在字符串开头添加 4 个 &#39;(&#39; 并在结尾添加 1 个 &#39;)&#39; ,字符串变成平衡字符串 &quot;(((())))))))&quot;
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s</code>&nbsp;只包含&nbsp;<code>&#39;(&#39;</code>&nbsp;<code>&#39;)&#39;</code>&nbsp;</li>
</ul>
<p>给你一个字符串 <code>s</code> 。请返回 <code>s</code> 中最长的 <strong>超赞子字符串</strong> 的长度。</p>
<p>「超赞子字符串」需满足满足下述两个条件:</p>
<ul>
<li>该字符串是 <code>s</code> 的一个非空子字符串</li>
<li>进行任意次数的字符交换后,该字符串可以变成一个回文字符串</li>
</ul>
<p>&nbsp;</p>
<p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>s = &quot;3242415&quot;
<strong>输出:</strong>5
<strong>解释:</strong>&quot;24241&quot; 是最长的超赞子字符串,交换其中的字符后,可以得到回文 &quot;24142&quot;
</pre>
<p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>s = &quot;12345678&quot;
<strong>输出:</strong>1
</pre>
<p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>s = &quot;213123&quot;
<strong>输出:</strong>6
<strong>解释:</strong>&quot;213123&quot; 是最长的超赞子字符串,交换其中的字符后,可以得到回文 &quot;231132&quot;
</pre>
<p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>s = &quot;00&quot;
<strong>输出:</strong>2
</pre>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
<li><code>s</code> 仅由数字组成</li>
</ul>
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册