Merge remote-tracking branch 'origin/master'
# Conflicts: # src/main/java/leetcode/editor/cn/all.json # src/main/java/leetcode/editor/cn/translation.json
This commit is contained in:
huangge1199@hotmail.com
commit
461c0593d0
81
src/main/java/leetcode/editor/cn/GasStation.java
Normal file
81
src/main/java/leetcode/editor/cn/GasStation.java
Normal file
@ -0,0 +1,81 @@
|
||||
//在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
|
||||
//
|
||||
// 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
|
||||
//
|
||||
// 如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。
|
||||
//
|
||||
// 说明:
|
||||
//
|
||||
//
|
||||
// 如果题目有解，该答案即为唯一答案。
|
||||
// 输入数组均为非空数组，且长度相同。
|
||||
// 输入数组中的元素均为非负数。
|
||||
//
|
||||
//
|
||||
// 示例 1:
|
||||
//
|
||||
// 输入:
|
||||
//gas = [1,2,3,4,5]
|
||||
//cost = [3,4,5,1,2]
|
||||
//
|
||||
//输出: 3
|
||||
//
|
||||
//解释:
|
||||
//从 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 可为起始索引。
|
||||
//
|
||||
// 示例 2:
|
||||
//
|
||||
// 输入:
|
||||
//gas = [2,3,4]
|
||||
//cost = [3,4,3]
|
||||
//
|
||||
//输出: -1
|
||||
//
|
||||
//解释:
|
||||
//你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
|
||||
//我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
|
||||
//开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
|
||||
//开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
|
||||
//你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
|
||||
//因此，无论怎样，你都不可能绕环路行驶一周。
|
||||
// Related Topics 贪心 数组
|
||||
// 👍 687 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//134:加油站
|
||||
public class GasStation {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new GasStation().new Solution();
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int canCompleteCircuit(int[] gas, int[] cost) {
|
||||
int index = 0;
|
||||
int min = Integer.MAX_VALUE;
|
||||
int oil = 0;
|
||||
for (int i = 0; i < gas.length; i++) {
|
||||
oil += gas[i] - cost[i];
|
||||
if (oil < min) {
|
||||
min = oil;
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
if (oil < 0) {
|
||||
return -1;
|
||||
}
|
||||
return (index + 1) % gas.length;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
47
src/main/java/leetcode/editor/cn/GasStation.md
Normal file
47
src/main/java/leetcode/editor/cn/GasStation.md
Normal file
@ -0,0 +1,47 @@
|
||||
<p>在一条环路上有 <em>N</em> 个加油站，其中第 <em>i</em> 个加油站有汽油 <code>gas[i]</code><em> </em>升。</p>
|
||||
|
||||
<p>你有一辆油箱容量无限的的汽车，从第<em> i </em>个加油站开往第<em> i+1 </em>个加油站需要消耗汽油 <code>cost[i]</code><em> </em>升。你从其中的一个加油站出发，开始时油箱为空。</p>
|
||||
|
||||
<p>如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。</p>
|
||||
|
||||
<p><strong>说明:</strong> </p>
|
||||
|
||||
<ul>
|
||||
<li>如果题目有解，该答案即为唯一答案。</li>
|
||||
<li>输入数组均为非空数组，且长度相同。</li>
|
||||
<li>输入数组中的元素均为非负数。</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>示例 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>
|
||||
<div><div>Related Topics</div><div><li>贪心</li><li>数组</li></div></div>\n<div><li>👍 687</li><li>👎 0</li></div>
|
||||
72
src/main/java/leetcode/editor/cn/JumpGameIi.java
Normal file
72
src/main/java/leetcode/editor/cn/JumpGameIi.java
Normal file
@ -0,0 +1,72 @@
|
||||
//给定一个非负整数数组，你最初位于数组的第一个位置。
|
||||
//
|
||||
// 数组中的每个元素代表你在该位置可以跳跃的最大长度。
|
||||
//
|
||||
// 你的目标是使用最少的跳跃次数到达数组的最后一个位置。
|
||||
//
|
||||
// 假设你总是可以到达数组的最后一个位置。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1:
|
||||
//
|
||||
//
|
||||
//输入: [2,3,1,1,4]
|
||||
//输出: 2
|
||||
//解释: 跳到最后一个位置的最小跳跃数是 2。
|
||||
// 从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
|
||||
//
|
||||
//
|
||||
// 示例 2:
|
||||
//
|
||||
//
|
||||
//输入: [2,3,0,1,4]
|
||||
//输出: 2
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示:
|
||||
//
|
||||
//
|
||||
// 1 <= nums.length <= 1000
|
||||
// 0 <= nums[i] <= 105
|
||||
//
|
||||
// Related Topics 贪心 数组 动态规划
|
||||
// 👍 1053 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
//45:跳跃游戏 II
|
||||
public class JumpGameIi{
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new JumpGameIi().new Solution();
|
||||
System.out.println(solution.jump(new int[]{2,3,1,1,4}));
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int jump(int[] nums) {
|
||||
if(nums.length==1){
|
||||
return 0;
|
||||
}
|
||||
int max = 0;
|
||||
int[] counts = new int[nums.length];
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
int next = i+nums[i];
|
||||
if(next>=nums.length-1){
|
||||
return counts[i]+1;
|
||||
}
|
||||
if(next>max){
|
||||
for (int j = max+1; j <= next; j++) {
|
||||
counts[j] = counts[i]+1;
|
||||
}
|
||||
max = next;
|
||||
}
|
||||
}
|
||||
return counts[nums.length-1];
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
35
src/main/java/leetcode/editor/cn/JumpGameIi.md
Normal file
35
src/main/java/leetcode/editor/cn/JumpGameIi.md
Normal file
@ -0,0 +1,35 @@
|
||||
<p>给定一个非负整数数组，你最初位于数组的第一个位置。</p>
|
||||
|
||||
<p>数组中的每个元素代表你在该位置可以跳跃的最大长度。</p>
|
||||
|
||||
<p>你的目标是使用最少的跳跃次数到达数组的最后一个位置。</p>
|
||||
|
||||
<p>假设你总是可以到达数组的最后一个位置。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [2,3,1,1,4]
|
||||
<strong>输出:</strong> 2
|
||||
<strong>解释:</strong> 跳到最后一个位置的最小跳跃数是 <code>2</code>。
|
||||
从下标为 0 跳到下标为 1 的位置，跳 <code>1</code> 步，然后跳 <code>3</code> 步到达数组的最后一个位置。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [2,3,0,1,4]
|
||||
<strong>输出:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>贪心</li><li>数组</li><li>动态规划</li></div></div>\n<div><li>👍 1053</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,52 @@
|
||||
//给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
|
||||
//
|
||||
// 请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1:
|
||||
//
|
||||
//
|
||||
//输入: [3,2,1,5,6,4] 和 k = 2
|
||||
//输出: 5
|
||||
//
|
||||
//
|
||||
// 示例 2:
|
||||
//
|
||||
//
|
||||
//输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
|
||||
//输出: 4
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= k <= nums.length <= 104
|
||||
// -104 <= nums[i] <= 104
|
||||
//
|
||||
// Related Topics 数组 分治 快速选择 排序 堆（优先队列）
|
||||
// 👍 1170 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Queue;
|
||||
|
||||
//215:数组中的第K个最大元素
|
||||
public class KthLargestElementInAnArray{
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new KthLargestElementInAnArray().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int findKthLargest(int[] nums, int k) {
|
||||
Arrays.sort(nums);
|
||||
return nums[nums.length-k];
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,28 @@
|
||||
<p>给定整数数组 <code>nums</code> 和整数 <code>k</code>，请返回数组中第 <code><strong>k</strong></code> 个最大的元素。</p>
|
||||
|
||||
<p>请注意，你需要找的是数组排序后的第 <code>k</code> 个最大的元素，而不是第 <code>k</code> 个不同的元素。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> <code>[3,2,1,5,6,4] 和</code> k = 2
|
||||
<strong>输出:</strong> 5
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> <code>[3,2,3,1,2,4,5,5,6] 和</code> k = 4
|
||||
<strong>输出:</strong> 4</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示： </strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>分治</li><li>快速选择</li><li>排序</li><li>堆（优先队列）</li></div></div>\n<div><li>👍 1170</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,91 @@
|
||||
//给你一个正整数数组 arr 。请你对 arr 执行一些操作（也可以不进行任何操作），使得数组满足以下条件：
|
||||
//
|
||||
//
|
||||
// arr 中 第一个 元素必须为 1 。
|
||||
// 任意相邻两个元素的差的绝对值 小于等于 1 ，也就是说，对于任意的 1 <= i < arr.length （数组下标从 0 开始），都满足 abs(ar
|
||||
//r[i] - arr[i - 1]) <= 1 。abs(x) 为 x 的绝对值。
|
||||
//
|
||||
//
|
||||
// 你可以执行以下 2 种操作任意次：
|
||||
//
|
||||
//
|
||||
// 减小 arr 中任意元素的值，使其变为一个 更小的正整数 。
|
||||
// 重新排列 arr 中的元素，你可以以任意顺序重新排列。
|
||||
//
|
||||
//
|
||||
// 请你返回执行以上操作后，在满足前文所述的条件下，arr 中可能的 最大值 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：arr = [2,2,1,2,1]
|
||||
//输出：2
|
||||
//解释：
|
||||
//我们可以重新排列 arr 得到 [1,2,2,2,1] ，该数组满足所有条件。
|
||||
//arr 中最大元素为 2 。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：arr = [100,1,1000]
|
||||
//输出：3
|
||||
//解释：
|
||||
//一个可行的方案如下：
|
||||
//1. 重新排列 arr 得到 [1,100,1000] 。
|
||||
//2. 将第二个元素减小为 2 。
|
||||
//3. 将第三个元素减小为 3 。
|
||||
//现在 arr = [1,2,3] ，满足所有条件。
|
||||
//arr 中最大元素为 3 。
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：arr = [1,2,3,4,5]
|
||||
//输出：5
|
||||
//解释：数组已经满足所有条件，最大元素为 5 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= arr.length <= 105
|
||||
// 1 <= arr[i] <= 109
|
||||
//
|
||||
// Related Topics 贪心 数组 排序
|
||||
// 👍 37 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
//1846:减小和重新排列数组后的最大元素
|
||||
public class MaximumElementAfterDecreasingAndRearranging{
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new MaximumElementAfterDecreasingAndRearranging().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int maximumElementAfterDecrementingAndRearranging(int[] arr) {
|
||||
Arrays.sort(arr);
|
||||
int count = 1;
|
||||
arr[0]=1;
|
||||
for (int i = 1; i < arr.length; i++) {
|
||||
if(arr[i]!=arr[i-1]){
|
||||
count++;
|
||||
arr[i]=arr[i-1]+1;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,59 @@
|
||||
<p>给你一个正整数数组 <code>arr</code> 。请你对 <code>arr</code> 执行一些操作（也可以不进行任何操作），使得数组满足以下条件：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>arr</code> 中 <strong>第一个</strong> 元素必须为 <code>1</code> 。</li>
|
||||
<li>任意相邻两个元素的差的绝对值 <strong>小于等于</strong> <code>1</code> ，也就是说，对于任意的 <code>1 <= i < arr.length</code> （<strong>数组下标从 0 开始</strong>），都满足 <code>abs(arr[i] - arr[i - 1]) <= 1</code> 。<code>abs(x)</code> 为 <code>x</code> 的绝对值。</li>
|
||||
</ul>
|
||||
|
||||
<p>你可以执行以下 2 种操作任意次：</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>减小</strong> <code>arr</code> 中任意元素的值，使其变为一个 <strong>更小的正整数</strong> 。</li>
|
||||
<li><strong>重新排列</strong> <code>arr</code> 中的元素，你可以以任意顺序重新排列。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回执行以上操作后，在满足前文所述的条件下，<code>arr</code> 中可能的 <strong>最大值</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>arr = [2,2,1,2,1]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>
|
||||
我们可以重新排列 arr 得到 <code>[1,2,2,2,1] ，该数组满足所有条件。</code>
|
||||
arr 中最大元素为 2 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>arr = [100,1,1000]
|
||||
<b>输出：</b>3
|
||||
<b>解释：</b>
|
||||
一个可行的方案如下：
|
||||
1. 重新排列 <code>arr</code> 得到 <code>[1,100,1000] 。</code>
|
||||
2. 将第二个元素减小为 2 。
|
||||
3. 将第三个元素减小为 3 。
|
||||
现在 <code>arr = [1,2,3] ，满足所有条件。</code>
|
||||
arr 中最大元素为 3 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>arr = [1,2,3,4,5]
|
||||
<b>输出：</b>5
|
||||
<b>解释：</b>数组已经满足所有条件，最大元素为 5 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= arr[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>贪心</li><li>数组</li><li>排序</li></div></div>\n<div><li>👍 37</li><li>👎 0</li></div>
|
||||
76
src/main/java/leetcode/editor/cn/MergeTwoBinaryTrees.java
Normal file
76
src/main/java/leetcode/editor/cn/MergeTwoBinaryTrees.java
Normal file
@ -0,0 +1,76 @@
|
||||
//给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
|
||||
//
|
||||
// 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点
|
||||
//。
|
||||
//
|
||||
// 示例 1:
|
||||
//
|
||||
//
|
||||
//输入:
|
||||
// Tree 1 Tree 2
|
||||
// 1 2
|
||||
// / \ / \
|
||||
// 3 2 1 3
|
||||
// / \ \
|
||||
// 5 4 7
|
||||
//输出:
|
||||
//合并后的树:
|
||||
// 3
|
||||
// / \
|
||||
// 4 5
|
||||
// / \ \
|
||||
// 5 4 7
|
||||
//
|
||||
//
|
||||
// 注意: 合并必须从两个树的根节点开始。
|
||||
// Related Topics 树 深度优先搜索 广度优先搜索 二叉树
|
||||
// 👍 724 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import com.code.leet.entiy.TreeNode;
|
||||
|
||||
//617:合并二叉树
|
||||
public class MergeTwoBinaryTrees {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new MergeTwoBinaryTrees().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* public class TreeNode {
|
||||
* int val;
|
||||
* TreeNode left;
|
||||
* TreeNode right;
|
||||
* TreeNode() {}
|
||||
* TreeNode(int val) { this.val = val; }
|
||||
* TreeNode(int val, TreeNode left, TreeNode right) {
|
||||
* this.val = val;
|
||||
* this.left = left;
|
||||
* this.right = right;
|
||||
* }
|
||||
* }
|
||||
*/
|
||||
class Solution {
|
||||
public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
|
||||
TreeNode head;
|
||||
if (root1 != null && root2 != null) {
|
||||
head = new TreeNode(root1.val + root2.val);
|
||||
head.left = mergeTrees(root1.left, root2.left);
|
||||
head.right = mergeTrees(root1.right, root2.right);
|
||||
} else if (root1 == null && root2 == null) {
|
||||
head = null;
|
||||
} else if (root1 == null) {
|
||||
head = root2;
|
||||
} else {
|
||||
head = root1;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
25
src/main/java/leetcode/editor/cn/MergeTwoBinaryTrees.md
Normal file
25
src/main/java/leetcode/editor/cn/MergeTwoBinaryTrees.md
Normal file
@ -0,0 +1,25 @@
|
||||
<p>给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。</p>
|
||||
|
||||
<p>你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则<strong>不为 </strong>NULL 的节点将直接作为新二叉树的节点。</p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
Tree 1 Tree 2
|
||||
1 2
|
||||
/ \ / \
|
||||
3 2 1 3
|
||||
/ \ \
|
||||
5 4 7
|
||||
<strong>输出:</strong>
|
||||
合并后的树:
|
||||
3
|
||||
/ \
|
||||
4 5
|
||||
/ \ \
|
||||
5 4 7
|
||||
</pre>
|
||||
|
||||
<p><strong>注意:</strong> 合并必须从两个树的根节点开始。</p>
|
||||
<div><div>Related Topics</div><div><li>树</li><li>深度优先搜索</li><li>广度优先搜索</li><li>二叉树</li></div></div>\n<div><li>👍 724</li><li>👎 0</li></div>
|
||||
96
src/main/java/leetcode/editor/cn/NextPermutation.java
Normal file
96
src/main/java/leetcode/editor/cn/NextPermutation.java
Normal file
@ -0,0 +1,96 @@
|
||||
//实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
|
||||
//
|
||||
// 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
|
||||
//
|
||||
// 必须 原地 修改，只允许使用额外常数空间。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：nums = [1,2,3]
|
||||
//输出：[1,3,2]
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：nums = [3,2,1]
|
||||
//输出：[1,2,3]
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：nums = [1,1,5]
|
||||
//输出：[1,5,1]
|
||||
//
|
||||
//
|
||||
// 示例 4：
|
||||
//
|
||||
//
|
||||
//输入：nums = [1]
|
||||
//输出：[1]
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= nums.length <= 100
|
||||
// 0 <= nums[i] <= 100
|
||||
//
|
||||
// Related Topics 数组 双指针
|
||||
// 👍 1221 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//31:下一个排列
|
||||
public class NextPermutation {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new NextPermutation().new Solution();
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public void nextPermutation(int[] nums) {
|
||||
if (nums.length < 2) {
|
||||
return;
|
||||
}
|
||||
int i = nums.length - 2;
|
||||
for (; i >= 0; i--) {
|
||||
if (nums[i] < nums[i + 1]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i != -1) {
|
||||
int j = i + 1;
|
||||
for (; j < nums.length; j++) {
|
||||
if (nums[j] <= nums[i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
swap(nums, i, j - 1);
|
||||
}
|
||||
int start = i + 1;
|
||||
int end = nums.length - 1;
|
||||
while (start < end) {
|
||||
swap(nums, start, end);
|
||||
start++;
|
||||
end--;
|
||||
}
|
||||
}
|
||||
|
||||
private void swap(int[] nums, int i, int j) {
|
||||
int temp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = temp;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
45
src/main/java/leetcode/editor/cn/NextPermutation.md
Normal file
45
src/main/java/leetcode/editor/cn/NextPermutation.md
Normal file
@ -0,0 +1,45 @@
|
||||
<p>实现获取 <strong>下一个排列</strong> 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。</p>
|
||||
|
||||
<p>如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。</p>
|
||||
|
||||
<p>必须<strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank"> 原地 </a></strong>修改，只允许使用额外常数空间。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3]
|
||||
<strong>输出：</strong>[1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,2,1]
|
||||
<strong>输出：</strong>[1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,1,5]
|
||||
<strong>输出：</strong>[1,5,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>0 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>双指针</li></div></div>\n<div><li>👍 1221</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,106 @@
|
||||
//给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
|
||||
//
|
||||
//
|
||||
//struct Node {
|
||||
// int val;
|
||||
// Node *left;
|
||||
// Node *right;
|
||||
// Node *next;
|
||||
//}
|
||||
//
|
||||
// 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
|
||||
//
|
||||
// 初始状态下，所有 next 指针都被设置为 NULL。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：
|
||||
//
|
||||
//
|
||||
// 你只能使用常量级额外空间。
|
||||
// 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例：
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//输入：root = [1,2,3,4,5,6,7]
|
||||
//输出：[1,#,2,3,#,4,5,6,7,#]
|
||||
//解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由
|
||||
//next 指针连接，'#' 标志着每一层的结束。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 树中节点的数量少于 4096
|
||||
// -1000 <= node.val <= 1000
|
||||
//
|
||||
// Related Topics 树 深度优先搜索 广度优先搜索 二叉树
|
||||
// 👍 494 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//116:填充每个节点的下一个右侧节点指针
|
||||
public class PopulatingNextRightPointersInEachNode {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new PopulatingNextRightPointersInEachNode().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
|
||||
// Definition for a Node.
|
||||
class Node {
|
||||
public int val;
|
||||
public Node left;
|
||||
public Node right;
|
||||
public Node next;
|
||||
|
||||
public Node() {
|
||||
}
|
||||
|
||||
public Node(int _val) {
|
||||
val = _val;
|
||||
}
|
||||
|
||||
public Node(int _val, Node _left, Node _right, Node _next) {
|
||||
val = _val;
|
||||
left = _left;
|
||||
right = _right;
|
||||
next = _next;
|
||||
}
|
||||
}
|
||||
|
||||
class Solution {
|
||||
public Node connect(Node root) {
|
||||
if (root == null) {
|
||||
return root;
|
||||
}
|
||||
Node cur = root;
|
||||
while (cur != null) {
|
||||
Node dummy = new Node(0);
|
||||
Node pre = dummy;
|
||||
|
||||
while (cur != null && cur.left != null) {
|
||||
pre.next = cur.left;
|
||||
pre = pre.next;
|
||||
|
||||
pre.next = cur.right;
|
||||
pre = pre.next;
|
||||
cur = cur.next;
|
||||
}
|
||||
cur = dummy.next;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
<p>给定一个 <strong>完美二叉树 </strong>，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：</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.com/uploads/2019/02/14/116_sample.png" style="height: 205px; width: 600px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [1,2,3,4,5,6,7]
|
||||
<b>输出：</b>[1,#,2,3,#,4,5,6,7,#]
|
||||
<b>解释：</b>给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数量少于 <code>4096</code></li>
|
||||
<li><code>-1000 <= node.val <= 1000</code></li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>树</li><li>深度优先搜索</li><li>广度优先搜索</li><li>二叉树</li></div></div>\n<div><li>👍 494</li><li>👎 0</li></div>
|
||||
107
src/main/java/leetcode/editor/cn/RottingOranges.java
Normal file
107
src/main/java/leetcode/editor/cn/RottingOranges.java
Normal file
@ -0,0 +1,107 @@
|
||||
//在给定的网格中，每个单元格可以有以下三个值之一：
|
||||
//
|
||||
//
|
||||
// 值 0 代表空单元格；
|
||||
// 值 1 代表新鲜橘子；
|
||||
// 值 2 代表腐烂的橘子。
|
||||
//
|
||||
//
|
||||
// 每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
|
||||
//
|
||||
// 返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//
|
||||
// 输入：[[2,1,1],[1,1,0],[0,1,1]]
|
||||
//输出：4
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
// 输入：[[2,1,1],[0,1,1],[1,0,1]]
|
||||
//输出：-1
|
||||
//解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
// 输入：[[0,2]]
|
||||
//输出：0
|
||||
//解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= grid.length <= 10
|
||||
// 1 <= grid[0].length <= 10
|
||||
// grid[i][j] 仅为 0、1 或 2
|
||||
//
|
||||
// Related Topics 广度优先搜索 数组 矩阵
|
||||
// 👍 382 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
//994:腐烂的橘子
|
||||
public class RottingOranges {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new RottingOranges().new Solution();
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int orangesRotting(int[][] grid) {
|
||||
Queue<int[]> queue = new LinkedList<>();
|
||||
int count = 0;
|
||||
for (int i = 0; i < grid.length; i++) {
|
||||
for (int j = 0; j < grid[0].length; j++) {
|
||||
if (grid[i][j] == 2) {
|
||||
queue.offer(new int[]{i, j});
|
||||
} else if (grid[i][j] == 1) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (count == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
List<int[]> list = Arrays.asList(
|
||||
new int[]{-1, 0},
|
||||
new int[]{1, 0},
|
||||
new int[]{0, -1},
|
||||
new int[]{0, 1}
|
||||
);
|
||||
int[][] is = new int[grid.length][grid[0].length];
|
||||
int time = -1;
|
||||
while (!queue.isEmpty()) {
|
||||
int[] arr = queue.poll();
|
||||
for (int[] point : list) {
|
||||
int x = arr[0] + point[0];
|
||||
int y = arr[1] + point[1];
|
||||
if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != 1) {
|
||||
continue;
|
||||
}
|
||||
is[x][y] = is[arr[0]][arr[1]] + 1;
|
||||
time = Math.max(time, is[x][y]);
|
||||
grid[x][y] = 2;
|
||||
queue.offer(new int[]{x, y});
|
||||
count--;
|
||||
}
|
||||
}
|
||||
return count > 0 ? -1 : time;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
46
src/main/java/leetcode/editor/cn/RottingOranges.md
Normal file
46
src/main/java/leetcode/editor/cn/RottingOranges.md
Normal file
@ -0,0 +1,46 @@
|
||||
<p>在给定的网格中，每个单元格可以有以下三个值之一：</p>
|
||||
|
||||
<ul>
|
||||
<li>值 <code>0</code> 代表空单元格；</li>
|
||||
<li>值 <code>1</code> 代表新鲜橘子；</li>
|
||||
<li>值 <code>2</code> 代表腐烂的橘子。</li>
|
||||
</ul>
|
||||
|
||||
<p>每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。</p>
|
||||
|
||||
<p>返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 <code>-1</code>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/02/16/oranges.png" style="height: 150px; width: 712px;"></strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>[[2,1,1],[1,1,0],[0,1,1]]
|
||||
<strong>输出：</strong>4
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>[[2,1,1],[0,1,1],[1,0,1]]
|
||||
<strong>输出：</strong>-1
|
||||
<strong>解释：</strong>左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>[[0,2]]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ol>
|
||||
<li><code>1 <= grid.length <= 10</code></li>
|
||||
<li><code>1 <= grid[0].length <= 10</code></li>
|
||||
<li><code>grid[i][j]</code> 仅为 <code>0</code>、<code>1</code> 或 <code>2</code></li>
|
||||
</ol>
|
||||
<div><div>Related Topics</div><div><li>广度优先搜索</li><li>数组</li><li>矩阵</li></div></div>\n<div><li>👍 382</li><li>👎 0</li></div>
|
||||
101
src/main/java/leetcode/editor/cn/Zero1Matrix.java
Normal file
101
src/main/java/leetcode/editor/cn/Zero1Matrix.java
Normal file
@ -0,0 +1,101 @@
|
||||
//给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。
|
||||
//
|
||||
// 两个相邻元素间的距离为 1 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：
|
||||
//[[0,0,0],
|
||||
// [0,1,0],
|
||||
// [0,0,0]]
|
||||
//
|
||||
//输出：
|
||||
//[[0,0,0],
|
||||
// [0,1,0],
|
||||
// [0,0,0]]
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：
|
||||
//[[0,0,0],
|
||||
// [0,1,0],
|
||||
// [1,1,1]]
|
||||
//
|
||||
//输出：
|
||||
//[[0,0,0],
|
||||
// [0,1,0],
|
||||
// [1,2,1]]
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 给定矩阵的元素个数不超过 10000。
|
||||
// 给定矩阵中至少有一个元素是 0。
|
||||
// 矩阵中的元素只在四个方向上相邻: 上、下、左、右。
|
||||
//
|
||||
// Related Topics 广度优先搜索 数组 动态规划 矩阵
|
||||
// 👍 446 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import javafx.util.Pair;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Queue;
|
||||
|
||||
//542:01 矩阵
|
||||
public class Zero1Matrix {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new Zero1Matrix().new Solution();
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int[][] updateMatrix(int[][] mat) {
|
||||
List<Pair<Integer, Integer>> list = Arrays.asList(
|
||||
new Pair<>(-1, 0),
|
||||
new Pair<>(1, 0),
|
||||
new Pair<>(0, -1),
|
||||
new Pair<>(0, 1)
|
||||
);
|
||||
Queue<int[]> queue = new LinkedList<>();
|
||||
boolean[][] is = new boolean[mat.length][mat[0].length];
|
||||
for (int i = 0; i < mat.length; i++) {
|
||||
for (int j = 0; j < mat[0].length; j++) {
|
||||
if (mat[i][j] == 0) {
|
||||
queue.offer(new int[]{i, j});
|
||||
is[i][j] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (!queue.isEmpty()) {
|
||||
int[] arr = queue.poll();
|
||||
for (Pair<Integer, Integer> pair : list) {
|
||||
int x = arr[0] + pair.getKey();
|
||||
int y = arr[1] + pair.getValue();
|
||||
if (x < 0 || x >= mat.length || y < 0 || y >= mat[0].length || is[x][y] || mat[x][y] != 1) {
|
||||
continue;
|
||||
}
|
||||
mat[x][y] = mat[arr[0]][arr[1]] + 1;
|
||||
is[x][y] = true;
|
||||
queue.offer(new int[]{x, y});
|
||||
}
|
||||
}
|
||||
return mat;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
44
src/main/java/leetcode/editor/cn/Zero1Matrix.md
Normal file
44
src/main/java/leetcode/editor/cn/Zero1Matrix.md
Normal file
@ -0,0 +1,44 @@
|
||||
<p>给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。</p>
|
||||
|
||||
<p>两个相邻元素间的距离为 1 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><b>示例 1：</b></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>
|
||||
[[0,0,0],
|
||||
[0,1,0],
|
||||
[0,0,0]]
|
||||
|
||||
<strong>输出：</strong>
|
||||
[[0,0,0],
|
||||
[0,1,0],
|
||||
[0,0,0]]
|
||||
</pre>
|
||||
|
||||
<p><b>示例 2：</b></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
[[0,0,0],
|
||||
[0,1,0],
|
||||
[1,1,1]]
|
||||
|
||||
<strong>输出：</strong>
|
||||
[[0,0,0],
|
||||
[0,1,0],
|
||||
[1,2,1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>给定矩阵的元素个数不超过 10000。</li>
|
||||
<li>给定矩阵中至少有一个元素是 0。</li>
|
||||
<li>矩阵中的元素只在四个方向上相邻: 上、下、左、右。</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>广度优先搜索</li><li>数组</li><li>动态规划</li><li>矩阵</li></div></div>\n<div><li>👍 446</li><li>👎 0</li></div>
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Loading…
Reference in New Issue
Block a user