mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 05:13:29 +08:00
update
This commit is contained in:
@@ -0,0 +1,54 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>. Your task is to perform the following operation <strong>exactly</strong> <code>k</code> times in order to maximize your score:</p>
|
||||
|
||||
<ol>
|
||||
<li>Select an element <code>m</code> from <code>nums</code>.</li>
|
||||
<li>Remove the selected element <code>m</code> from the array.</li>
|
||||
<li>Add a new element with a value of <code>m + 1</code> to the array.</li>
|
||||
<li>Increase your score by <code>m</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>the maximum score you can achieve after performing the operation exactly</em> <code>k</code> <em>times.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5], k = 3
|
||||
<strong>Output:</strong> 18
|
||||
<strong>Explanation:</strong> We need to choose exactly 3 elements from nums to maximize the sum.
|
||||
For the first iteration, we choose 5. Then sum is 5 and nums = [1,2,3,4,6]
|
||||
For the second iteration, we choose 6. Then sum is 5 + 6 and nums = [1,2,3,4,7]
|
||||
For the third iteration, we choose 7. Then sum is 5 + 6 + 7 = 18 and nums = [1,2,3,4,8]
|
||||
So, we will return 18.
|
||||
It can be proven, that 18 is the maximum answer that we can achieve.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,5,5], k = 2
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> We need to choose exactly 2 elements from nums to maximize the sum.
|
||||
For the first iteration, we choose 5. Then sum is 5 and nums = [5,5,6]
|
||||
For the second iteration, we choose 6. Then sum is 5 + 6 = 11 and nums = [5,5,7]
|
||||
So, we will return 11.
|
||||
It can be proven, that 11 is the maximum answer that we can achieve.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 100</code></li>
|
||||
<li><code>1 <= k <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0;
|
||||
}
|
||||
.spoiler {overflow:hidden;}
|
||||
.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
|
||||
.spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
|
||||
.spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
|
||||
</style>
|
||||
@@ -0,0 +1,61 @@
|
||||
<p>You are given two <strong>0-indexed</strong> integer arrays <code><font face="monospace">player1</font></code> and <code>player2</code>, that represent the number of pins that player 1 and player 2 hit in a bowling game, respectively.</p>
|
||||
|
||||
<p>The bowling game consists of <code>n</code> turns, and the number of pins in each turn is exactly <code>10</code>.</p>
|
||||
|
||||
<p>Assume a player hit <code>x<sub>i</sub></code> pins in the <code>i<sup>th</sup></code> turn. The value of the <code>i<sup>th</sup></code> turn for the player is:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>2x<sub>i</sub></code> if the player hit <code>10</code> pins in any of the previous two turns.</li>
|
||||
<li>Otherwise, It is <code>x<sub>i</sub></code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The score of the player is the sum of the values of their <code>n</code> turns.</p>
|
||||
|
||||
<p>Return</p>
|
||||
|
||||
<ul>
|
||||
<li><code>1</code> <em>if the score of player 1 is more than the score of player 2,</em></li>
|
||||
<li><code>2</code> <em>if the score of player 2 is more than the score of player 1, and</em></li>
|
||||
<li><code>0</code> <em>in case of a draw.</em></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> player1 = [4,10,7,9], player2 = [6,5,2,3]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The score of player1 is 4 + 10 + 2*7 + 2*9 = 46.
|
||||
The score of player2 is 6 + 5 + 2 + 3 = 16.
|
||||
Score of player1 is more than the score of player2, so, player1 is the winner, and the answer is 1.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> player1 = [3,5,7,6], player2 = [8,10,10,2]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The score of player1 is 3 + 5 + 7 + 6 = 21.
|
||||
The score of player2 is 8 + 10 + 2*10 + 2*2 = 42.
|
||||
Score of player2 is more than the score of player1, so, player2 is the winner, and the answer is 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> player1 = [2,3], player2 = [4,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> The score of player1 is 2 + 3 = 5
|
||||
The score of player2 is 4 + 1 = 5
|
||||
The score of player1 equals to the score of player2, so, there is a draw, and the answer is 0.
|
||||
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == player1.length == player2.length</code></li>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
<li><code>0 <= player1[i], player2[i] <= 10</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given an array <code>start</code> where <code>start = [startX, startY]</code> represents your initial position <code>(startX, startY)</code> in a 2D space. You are also given the array <code>target</code> where <code>target = [targetX, targetY]</code> represents your target position <code>(targetX, targetY)</code>.</p>
|
||||
|
||||
<p>The cost of going from a position <code>(x1, y1)</code> to any other position in the space <code>(x2, y2)</code> is <code>|x2 - x1| + |y2 - y1|</code>.</p>
|
||||
|
||||
<p>There are also some special roads. You are given a 2D array <code>specialRoads</code> where <code>specialRoads[i] = [x1<sub>i</sub>, y1<sub>i</sub>, x2<sub>i</sub>, y2<sub>i</sub>, cost<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> special road can take you from <code>(x1<sub>i</sub>, y1<sub>i</sub>)</code> to <code>(x2<sub>i</sub>, y2<sub>i</sub>)</code> with a cost equal to <code>cost<sub>i</sub></code>. You can use each special road any number of times.</p>
|
||||
|
||||
<p>Return <em>the minimum cost required to go from</em> <code>(startX, startY)</code> to <code>(targetX, targetY)</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> start = [1,1], target = [4,5], specialRoads = [[1,2,3,3,2],[3,4,4,5,1]]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The optimal path from (1,1) to (4,5) is the following:
|
||||
- (1,1) -> (1,2). This move has a cost of |1 - 1| + |2 - 1| = 1.
|
||||
- (1,2) -> (3,3). This move uses the first special edge, the cost is 2.
|
||||
- (3,3) -> (3,4). This move has a cost of |3 - 3| + |4 - 3| = 1.
|
||||
- (3,4) -> (4,5). This move uses the second special edge, the cost is 1.
|
||||
So the total cost is 1 + 2 + 1 + 1 = 5.
|
||||
It can be shown that we cannot achieve a smaller total cost than 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> start = [3,2], target = [5,7], specialRoads = [[3,2,3,4,4],[3,3,5,5,5],[3,4,5,6,6]]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> It is optimal to not use any special edges and go directly from the starting to the ending position with a cost |5 - 3| + |7 - 2| = 7.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>start.length == target.length == 2</code></li>
|
||||
<li><code>1 <= startX <= targetX <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= startY <= targetY <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= specialRoads.length <= 200</code></li>
|
||||
<li><code>specialRoads[i].length == 5</code></li>
|
||||
<li><code>startX <= x1<sub>i</sub>, x2<sub>i</sub> <= targetX</code></li>
|
||||
<li><code>startY <= y1<sub>i</sub>, y2<sub>i</sub> <= targetY</code></li>
|
||||
<li><code>1 <= cost<sub>i</sub> <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>A string is <strong>beautiful</strong> if:</p>
|
||||
|
||||
<ul>
|
||||
<li>It consists of the first <code>k</code> letters of the English lowercase alphabet.</li>
|
||||
<li>It does not contain any substring of length <code>2</code> or more which is a palindrome.</li>
|
||||
</ul>
|
||||
|
||||
<p>You are given a beautiful string <code>s</code> of length <code>n</code> and a positive integer <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>the lexicographically smallest string of length </em><code>n</code><em>, which is larger than </em><code>s</code><em> and is <strong>beautiful</strong></em>. If there is no such string, return an empty string.</p>
|
||||
|
||||
<p>A string <code>a</code> is lexicographically larger than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, <code>a</code> has a character strictly larger than the corresponding character in <code>b</code>.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"abcd"</code> is lexicographically larger than <code>"abcc"</code> because the first position they differ is at the fourth character, and <code>d</code> is greater than <code>c</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abcz", k = 26
|
||||
<strong>Output:</strong> "abda"
|
||||
<strong>Explanation:</strong> The string "abda" is beautiful and lexicographically larger than the string "abcz".
|
||||
It can be proven that there is no string that is lexicographically larger than the string "abcz", beautiful, and lexicographically smaller than the string "abda".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "dc", k = 4
|
||||
<strong>Output:</strong> ""
|
||||
<strong>Explanation:</strong> It can be proven that there is no string that is lexicographically larger than the string "dc" and is beautiful.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>4 <= k <= 26</code></li>
|
||||
<li><code>s</code> is a beautiful string.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,124 @@
|
||||
<p>You are given an integer array <code>nums</code> containing <strong>distinct</strong> numbers, and you can perform the following operations <strong>until the array is empty</strong>:</p>
|
||||
|
||||
<ul>
|
||||
<li>If the first element has the <strong>smallest</strong> value, remove it</li>
|
||||
<li>Otherwise, put the first element at the <strong>end</strong> of the array.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer denoting the number of operations it takes to make </em><code>nums</code><em> empty.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,4,-1]
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<table style="border: 2px solid black; border-collapse: collapse;">
|
||||
<thead>
|
||||
<tr>
|
||||
<th style="border: 2px solid black; padding: 5px;">Operation</th>
|
||||
<th style="border: 2px solid black; padding: 5px;">Array</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">1</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[4, -1, 3]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">2</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[-1, 3, 4]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">3</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[3, 4]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">4</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[4]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">5</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[]</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,4,3]
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<table style="border: 2px solid black; border-collapse: collapse;">
|
||||
<thead>
|
||||
<tr>
|
||||
<th style="border: 2px solid black; padding: 5px;">Operation</th>
|
||||
<th style="border: 2px solid black; padding: 5px;">Array</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">1</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[2, 4, 3]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">2</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[4, 3]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">3</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[3, 4]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">4</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[4]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">5</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[]</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<table style="border: 2px solid black; border-collapse: collapse;">
|
||||
<thead>
|
||||
<tr>
|
||||
<th style="border: 2px solid black; padding: 5px;">Operation</th>
|
||||
<th style="border: 2px solid black; padding: 5px;">Array</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">1</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[2, 3]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">2</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[3]</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 2px solid black; padding: 5px;">3</td>
|
||||
<td style="border: 2px solid black; padding: 5px;">[]</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>9 </sup><= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li>All values in <code>nums</code> are <strong>distinct</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>arr</code>, and an <code>m x n</code> integer <strong>matrix</strong> <code>mat</code>. <code>arr</code> and <code>mat</code> both contain <strong>all</strong> the integers in the range <code>[1, m * n]</code>.</p>
|
||||
|
||||
<p>Go through each index <code>i</code> in <code>arr</code> starting from index <code>0</code> and paint the cell in <code>mat</code> containing the integer <code>arr[i]</code>.</p>
|
||||
|
||||
<p>Return <em>the smallest index</em> <code>i</code> <em>at which either a row or a column will be completely painted in</em> <code>mat</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="image explanation for example 1" /><img alt="image explanation for example 1" src="https://assets.leetcode.com/uploads/2023/01/18/grid1.jpg" style="width: 321px; height: 81px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [1,3,4,2], mat = [[1,4],[2,3]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The moves are shown in order, and both the first row and second column of the matrix become fully painted at arr[2].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="image explanation for example 2" src="https://assets.leetcode.com/uploads/2023/01/18/grid2.jpg" style="width: 601px; height: 121px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The second column becomes fully painted at arr[3].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == mat.length</code></li>
|
||||
<li><code>n = mat[i].length</code></li>
|
||||
<li><code>arr.length == m * n</code></li>
|
||||
<li><code>1 <= m, n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= arr[i], mat[r][c] <= m * n</code></li>
|
||||
<li>All the integers of <code>arr</code> are <strong>unique</strong>.</li>
|
||||
<li>All the integers of <code>mat</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>You are given two <strong>0-indexed </strong>integer<strong> </strong>permutations <code>A</code> and <code>B</code> of length <code>n</code>.</p>
|
||||
|
||||
<p>A <strong>prefix common array</strong> of <code>A</code> and <code>B</code> is an array <code>C</code> such that <code>C[i]</code> is equal to the count of numbers that are present at or before the index <code>i</code> in both <code>A</code> and <code>B</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>prefix common array</strong> of </em><code>A</code><em> and </em><code>B</code>.</p>
|
||||
|
||||
<p>A sequence of <code>n</code> integers is called a <strong>permutation</strong> if it contains all integers from <code>1</code> to <code>n</code> exactly once.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> A = [1,3,2,4], B = [3,1,2,4]
|
||||
<strong>Output:</strong> [0,2,3,4]
|
||||
<strong>Explanation:</strong> At i = 0: no number is common, so C[0] = 0.
|
||||
At i = 1: 1 and 3 are common in A and B, so C[1] = 2.
|
||||
At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
|
||||
At i = 3: 1, 2, 3, and 4 are common in A and B, so C[3] = 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> A = [2,3,1], B = [3,1,2]
|
||||
<strong>Output:</strong> [0,1,3]
|
||||
<strong>Explanation:</strong> At i = 0: no number is common, so C[0] = 0.
|
||||
At i = 1: only 3 is common in A and B, so C[1] = 1.
|
||||
At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= A.length == B.length == n <= 50</code></li>
|
||||
<li><code>1 <= A[i], B[i] <= n</code></li>
|
||||
<li><code>It is guaranteed that A and B are both a permutation of n integers.</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D matrix <code>grid</code> of size <code>m x n</code>, where <code>(r, c)</code> represents:</p>
|
||||
|
||||
<ul>
|
||||
<li>A <strong>land</strong> cell if <code>grid[r][c] = 0</code>, or</li>
|
||||
<li>A <strong>water</strong> cell containing <code>grid[r][c]</code> fish, if <code>grid[r][c] > 0</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>A fisher can start at any <strong>water</strong> cell <code>(r, c)</code> and can do the following operations any number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Catch all the fish at cell <code>(r, c)</code>, or</li>
|
||||
<li>Move to any adjacent <strong>water</strong> cell.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> number of fish the fisher can catch if he chooses his starting cell optimally, or </em><code>0</code> if no water cell exists.</p>
|
||||
|
||||
<p>An <strong>adjacent</strong> cell of the cell <code>(r, c)</code>, is one of the cells <code>(r, c + 1)</code>, <code>(r, c - 1)</code>, <code>(r + 1, c)</code> or <code>(r - 1, c)</code> if it exists.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/29/example.png" style="width: 241px; height: 161px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> The fisher can start at cell <code>(1,3)</code> and collect 3 fish, then move to cell <code>(2,3)</code> and collect 4 fish.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/29/example2.png" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The fisher can start at cells (0,0) or (3,3) and collect a single fish.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 10</code></li>
|
||||
<li><code>0 <= grid[i][j] <= 10</code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user