mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-04 23:11:41 +08:00
update
This commit is contained in:
@@ -0,0 +1,40 @@
|
||||
<p>You are given an integer array <code>nums</code>. You need to create a 2D array from <code>nums</code> satisfying the following conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li>The 2D array should contain <strong>only</strong> the elements of the array <code>nums</code>.</li>
|
||||
<li>Each row in the 2D array contains <strong>distinct</strong> integers.</li>
|
||||
<li>The number of rows in the 2D array should be <strong>minimal</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the resulting array</em>. If there are multiple answers, return any of them.</p>
|
||||
|
||||
<p><strong>Note</strong> that the 2D array can have a different number of elements on each row.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,4,1,2,3,1]
|
||||
<strong>Output:</strong> [[1,3,4,2],[1,3],[1]]
|
||||
<strong>Explanation:</strong> We can create a 2D array that contains the following rows:
|
||||
- 1,3,4,2
|
||||
- 1,3
|
||||
- 1
|
||||
All elements of nums were used, and each row of the 2D array contains distinct integers, so it is a valid answer.
|
||||
It can be shown that we cannot have less than 3 rows in a valid array.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> [[4,3,2,1]]
|
||||
<strong>Explanation:</strong> All elements of the array are distinct, so we can keep all of them in the first row of the 2D array.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 200</code></li>
|
||||
<li><code>1 <= nums[i] <= nums.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a binary string <code>s</code> consisting only of zeroes and ones.</p>
|
||||
|
||||
<p>A substring of <code>s</code> is considered balanced if<strong> all zeroes are before ones</strong> and the number of zeroes is equal to the number of ones inside the substring. Notice that the empty substring is considered a balanced substring.</p>
|
||||
|
||||
<p>Return <em>the length of the longest balanced substring of </em><code>s</code>.</p>
|
||||
|
||||
<p>A <b>substring</b> is a contiguous sequence of characters within a string.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "01000111"
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The longest balanced substring is "000111", which has length 6.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "00111"
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The longest balanced substring is "0011", which has length 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "111"
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> There is no balanced substring except the empty substring, so the answer is 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 50</code></li>
|
||||
<li><code>'0' <= s[i] <= '1'</code></li>
|
||||
</ul>
|
||||
50
leetcode/problem/find-the-substring-with-maximum-cost.html
Normal file
50
leetcode/problem/find-the-substring-with-maximum-cost.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<p>You are given a string <code>s</code>, a string <code>chars</code> of <strong>distinct</strong> characters and an integer array <code>vals</code> of the same length as <code>chars</code>.</p>
|
||||
|
||||
<p>The <strong>cost of the substring </strong>is the sum of the values of each character in the substring. The cost of an empty string is considered <code>0</code>.</p>
|
||||
|
||||
<p>The <strong>value of the character </strong>is defined in the following way:</p>
|
||||
|
||||
<ul>
|
||||
<li>If the character is not in the string <code>chars</code>, then its value is its corresponding position <strong>(1-indexed)</strong> in the alphabet.
|
||||
|
||||
<ul>
|
||||
<li>For example, the value of <code>'a'</code> is <code>1</code>, the value of <code>'b'</code> is <code>2</code>, and so on. The value of <code>'z'</code> is <code>26</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Otherwise, assuming <code>i</code> is the index where the character occurs in the string <code>chars</code>, then its value is <code>vals[i]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the maximum cost among all substrings of the string</em> <code>s</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "adaa", chars = "d", vals = [-1000]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The value of the characters "a" and "d" is 1 and -1000 respectively.
|
||||
The substring with the maximum cost is "aa" and its cost is 1 + 1 = 2.
|
||||
It can be proven that 2 is the maximum cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abc", chars = "abc", vals = [-1,-1,-1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> The value of the characters "a", "b" and "c" is -1, -1, and -1 respectively.
|
||||
The substring with the maximum cost is the empty substring "" and its cost is 0.
|
||||
It can be proven that 0 is the maximum cost.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> consist of lowercase English letters.</li>
|
||||
<li><code>1 <= chars.length <= 26</code></li>
|
||||
<li><code>chars</code> consist of <strong>distinct</strong> lowercase English letters.</li>
|
||||
<li><code>vals.length == chars.length</code></li>
|
||||
<li><code>-1000 <= vals[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
Given two arrays of <strong>unique</strong> digits <code>nums1</code> and <code>nums2</code>, return <em>the <strong>smallest</strong> number that contains <strong>at least</strong> one digit from each array</em>.
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [4,1,3], nums2 = [5,7]
|
||||
<strong>Output:</strong> 15
|
||||
<strong>Explanation:</strong> The number 15 contains the digit 1 from nums1 and the digit 5 from nums2. It can be proven that 15 is the smallest number we can have.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [3,5,2,6], nums2 = [3,1,7]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The number 3 contains the digit 3 which exists in both arrays.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 9</code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= 9</code></li>
|
||||
<li>All digits in each array are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
46
leetcode/problem/make-k-subarray-sums-equal.html
Normal file
46
leetcode/problem/make-k-subarray-sums-equal.html
Normal file
@@ -0,0 +1,46 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>arr</code> and an integer <code>k</code>. The array <code>arr</code> is circular. In other words, the first element of the array is the next element of the last element, and the last element of the array is the previous element of the first element.</p>
|
||||
|
||||
<p>You can do the following operation any number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Pick any element from <code>arr</code> and increase or decrease it by <code>1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the minimum number of operations such that the sum of each <strong>subarray</strong> of length </em><code>k</code><em> is equal</em>.</p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous part of the array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,4,1,3], k = 2
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> we can do one operation on index 1 to make its value equal to 3.
|
||||
The array after the operation is [1,3,1,3]
|
||||
- Subarray starts at index 0 is [1, 3], and its sum is 4
|
||||
- Subarray starts at index 1 is [3, 1], and its sum is 4
|
||||
- Subarray starts at index 2 is [1, 3], and its sum is 4
|
||||
- Subarray starts at index 3 is [3, 1], and its sum is 4
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [2,5,5,7], k = 3
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> we can do three operations on index 0 to make its value equal to 5 and two operations on index 3 to make its value equal to 5.
|
||||
The array after the operations is [5,5,5,5]
|
||||
- Subarray starts at index 0 is [5, 5, 5], and its sum is 15
|
||||
- Subarray starts at index 1 is [5, 5, 5], and its sum is 15
|
||||
- Subarray starts at index 2 is [5, 5, 5], and its sum is 15
|
||||
- Subarray starts at index 3 is [5, 5, 5], and its sum is 15
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= arr.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= arr[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
42
leetcode/problem/mice-and-cheese.html
Normal file
42
leetcode/problem/mice-and-cheese.html
Normal file
@@ -0,0 +1,42 @@
|
||||
<p>There are two mice and <code>n</code> different types of cheese, each type of cheese should be eaten by exactly one mouse.</p>
|
||||
|
||||
<p>A point of the cheese with index <code>i</code> (<strong>0-indexed</strong>) is:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>reward1[i]</code> if the first mouse eats it.</li>
|
||||
<li><code>reward2[i]</code> if the second mouse eats it.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are given a positive integer array <code>reward1</code>, a positive integer array <code>reward2</code>, and a non-negative integer <code>k</code>.</p>
|
||||
|
||||
<p>Return <em><strong>the maximum</strong> points the mice can achieve if the first mouse eats exactly </em><code>k</code><em> types of cheese.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> reward1 = [1,1,3,4], reward2 = [4,4,1,1], k = 2
|
||||
<strong>Output:</strong> 15
|
||||
<strong>Explanation:</strong> In this example, the first mouse eats the 2<sup>nd</sup> (0-indexed) and the 3<sup>rd</sup> types of cheese, and the second mouse eats the 0<sup>th</sup> and the 1<sup>st</sup> types of cheese.
|
||||
The total points are 4 + 4 + 3 + 4 = 15.
|
||||
It can be proven that 15 is the maximum total points that the mice can achieve.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> reward1 = [1,1], reward2 = [1,1], k = 2
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> In this example, the first mouse eats the 0<sup>th</sup> (0-indexed) and 1<sup>st</sup> types of cheese, and the second mouse does not eat any cheese.
|
||||
The total points are 1 + 1 = 2.
|
||||
It can be proven that 2 is the maximum total points that the mice can achieve.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == reward1.length == reward2.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= reward1[i], reward2[i] <= 1000</code></li>
|
||||
<li><code>0 <= k <= n</code></li>
|
||||
</ul>
|
||||
51
leetcode/problem/minimum-reverse-operations.html
Normal file
51
leetcode/problem/minimum-reverse-operations.html
Normal file
@@ -0,0 +1,51 @@
|
||||
<p>You are given an integer <code>n</code> and an integer <code>p</code> in the range <code>[<font face="monospace">0</font>, n - 1]</code>. Representing a <strong>0-indexed</strong> array <code>arr</code> of length <code>n</code> where all positions are set to <code>0</code>'s, except position <code>p</code> which is set to <code>1</code>.</p>
|
||||
|
||||
<p>You are also given an integer array <code>banned</code> containing some positions from the array. For the <strong>i</strong><sup><strong>th</strong></sup> position in <code>banned</code>, <code>arr[banned[i]] = 0</code>, and <code>banned[i] != p</code>.</p>
|
||||
|
||||
<p>You can perform <strong>multiple</strong> operations on <code>arr</code>. In an operation, you can choose a <strong>subarray</strong> with size <code>k</code> and <strong>reverse</strong> the subarray. However, the <code>1</code> in <code>arr</code> should never go to any of the positions in <code>banned</code>. In other words, after each operation <code>arr[banned[i]]</code> <strong>remains</strong> <code>0</code>.</p>
|
||||
|
||||
<p><em>Return an array</em> <code>ans</code> <em>where</em><em> for each </em><code>i</code><em> from </em><code>[0, n - 1]</code>, <code>ans[i]</code> <em>is the <strong>minimum</strong> number of reverse operations needed to bring the</em> <code>1</code> <em>to position</em> <code>i</code><em> in arr</em>, <em>or</em> <code>-1</code> <em>if it is impossible</em>.</p>
|
||||
|
||||
<ul>
|
||||
<li>A <strong>subarray</strong> is a contiguous <strong>non-empty</strong> sequence of elements within an array.</li>
|
||||
<li>The values of <code>ans[i]</code> are independent for all <code>i</code>'s.</li>
|
||||
<li>The <strong>reverse </strong>of an array is an array containing the values in <strong>reverse order</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, p = 0, banned = [1,2], k = 4
|
||||
<strong>Output:</strong> [0,-1,-1,1]
|
||||
<strong>Explanation:</strong> In this case <code>k = 4</code> so there is only one possible reverse operation we can perform, which is reversing the whole array. Initially, 1<strong> </strong>is placed at position 0 so the amount of operations we need for position 0 is <code>0</code>. We can never place a 1 on the banned positions, so the answer for positions 1 and 2 is <code>-1</code>. Finally, with one reverse operation we can bring the 1 to index 3, so the answer for position 3 is <code>1</code>.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, p = 0, banned = [2,4], k = 3
|
||||
<strong>Output:</strong> [0,-1,-1,-1,-1]
|
||||
<strong>Explanation:</strong> In this case the 1 is initially at position 0, so the answer for that position is <code>0</code>. We can perform reverse operations of size 3. The 1 is currently located at position 0, so we need to reverse the subarray <code>[0, 2]</code> for it to leave that position, but reversing that subarray makes position 2 have a 1, which shouldn't happen. So, we can't move the 1 from position 0, making the result for all the other positions <code>-1</code>.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, p = 2, banned = [0,1,3], k = 1
|
||||
<strong>Output:</strong> [-1,-1,0,-1]
|
||||
<strong>Explanation:</strong> In this case we can only perform reverse operations of size 1.<strong> </strong>So the 1 never changes its position.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= p <= n - 1</code></li>
|
||||
<li><code>0 <= banned.length <= n - 1</code></li>
|
||||
<li><code>0 <= banned[i] <= n - 1</code></li>
|
||||
<li><code>1 <= k <= n </code></li>
|
||||
<li><code>banned[i] != p</code></li>
|
||||
<li>all values in <code>banned</code> are <strong>unique</strong> </li>
|
||||
</ul>
|
||||
34
leetcode/problem/shortest-cycle-in-a-graph.html
Normal file
34
leetcode/problem/shortest-cycle-in-a-graph.html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>There is a <strong>bi-directional </strong>graph with <code>n</code> vertices, where each vertex is labeled from <code>0</code> to <code>n - 1</code>. The edges in the graph are represented by a given 2D integer array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> denotes an edge between vertex <code>u<sub>i</sub></code> and vertex <code>v<sub>i</sub></code>. Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.</p>
|
||||
|
||||
<p>Return <em>the length of the <strong>shortest </strong>cycle in the graph</em>. If no cycle exists, return <code>-1</code>.</p>
|
||||
|
||||
<p>A cycle is a path that starts and ends at the same node, and each edge in the path is used only once.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/04/cropped.png" style="width: 387px; height: 331px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[0,1],[1,2],[2,0],[3,4],[4,5],[5,6],[6,3]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The cycle with the smallest length is : 0 -> 1 -> 2 -> 0
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/04/croppedagin.png" style="width: 307px; height: 307px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, edges = [[0,1],[0,2]]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> There are no cycles in this graph.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 1000</code></li>
|
||||
<li><code>1 <= edges.length <= 1000</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code></li>
|
||||
<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
|
||||
<li>There are no repeated edges.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user