Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/main/java/leetcode/editor/cn/all.json
#	src/main/java/leetcode/editor/cn/translation.json

src/main/java/leetcode/editor/cn/KClosestPointsToOrigin.java

@@ -0,0 +1,60 @@
+//我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。 
+//
+// （这里，平面上两点之间的距离是欧几里德距离。） 
+//
+// 你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：points = [[1,3],[-2,2]], K = 1
+//输出：[[-2,2]]
+//解释： 
+//(1, 3) 和原点之间的距离为 sqrt(10)，
+//(-2, 2) 和原点之间的距离为 sqrt(8)，
+//由于 sqrt(8) < sqrt(10)，(-2, 2) 离原点更近。
+//我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。
+// 
+//
+// 示例 2： 
+//
+// 输入：points = [[3,3],[5,-1],[-2,4]], K = 2
+//输出：[[3,3],[-2,4]]
+//（答案 [[-2,4],[3,3]] 也会被接受。）
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= K <= points.length <= 10000 
+// -10000 < points[i][0] < 10000 
+// -10000 < points[i][1] < 10000 
+// 
+// Related Topics 堆 排序 分治算法 
+// 👍 249 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+//973:最接近原点的 K 个点
+class KClosestPointsToOrigin{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new KClosestPointsToOrigin().new Solution();
+    }
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int[][] kClosest(int[][] points, int k) {
+        Arrays.sort(points, Comparator.comparingInt(point -> (point[0] * point[0] + point[1] * point[1])));
+        return Arrays.copyOfRange(points, 0, k);
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/KClosestPointsToOrigin.md

@@ -0,0 +1,36 @@
+<p>我们有一个由平面上的点组成的列表 <code>points</code>。需要从中找出 <code>K</code> 个距离原点 <code>(0, 0)</code> 最近的点。</p>
+
+<p>（这里，平面上两点之间的距离是欧几里德距离。）</p>
+
+<p>你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>points = [[1,3],[-2,2]], K = 1
+<strong>输出：</strong>[[-2,2]]
+<strong>解释： </strong>
+(1, 3) 和原点之间的距离为 sqrt(10)，
+(-2, 2) 和原点之间的距离为 sqrt(8)，
+由于 sqrt(8) &lt; sqrt(10)，(-2, 2) 离原点更近。
+我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>points = [[3,3],[5,-1],[-2,4]], K = 2
+<strong>输出：</strong>[[3,3],[-2,4]]
+（答案 [[-2,4],[3,3]] 也会被接受。）
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= K &lt;= points.length &lt;= 10000</code></li>
+	<li><code>-10000 &lt; points[i][0] &lt; 10000</code></li>
+	<li><code>-10000 &lt; points[i][1] &lt; 10000</code></li>
+</ol>
+<div><div>Related Topics</div><div><li>堆</li><li>排序</li><li>分治算法</li></div></div>\n<div><li>👍 249</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/KClosestPointsToOrigin184048045.txt

@@ -0,0 +1,9 @@
+class Solution {
+    public int[][] kClosest(int[][] points, int k) {
+        Arrays.sort(points, Comparator.comparingInt(point -> (point[0] * point[0] + point[1] * point[1])));
+        return Arrays.copyOfRange(points, 0, k);
+    }
+}
+
+//runtime:34 ms
+//memory:47.4 MB

src/main/java/leetcode/editor/cn/OnesAndZeroes.java

@@ -0,0 +1,74 @@
+//给你一个二进制字符串数组 strs 和两个整数 m 和 n 。 
+//
+// 
+// 请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。 
+//
+// 如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。 
+// 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
+//输出：4
+//解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
+//其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 
+//n 的值 3 。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：strs = ["10", "0", "1"], m = 1, n = 1
+//输出：2
+//解释：最大的子集是 {"0", "1"} ，所以答案是 2 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= strs.length <= 600 
+// 1 <= strs[i].length <= 100 
+// strs[i] 仅由 '0' 和 '1' 组成 
+// 1 <= m, n <= 100 
+// 
+// Related Topics 动态规划 
+// 👍 481 👎 0
+
+package leetcode.editor.cn;
+
+//474:一和零
+class OnesAndZeroes {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new OnesAndZeroes().new Solution();
+        System.out.println(solution.findMaxForm(new String[]{"10", "0001", "111001", "1", "0"}, 5, 3));
+        System.out.println(solution.findMaxForm(new String[]{"10", "0", "1"}, 1, 1));
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int findMaxForm(String[] strs, int m, int n) {
+            int[][] dp = new int[m+1][n+1];
+            for (String str : strs) {
+                int size = str.length();
+                int num0 = str.replace("1", "").length();
+                int num1 = size - num0;
+
+                for (int i = m; i >= num0; i--) {
+                    for (int j = n; j >= num1; j--) {
+                        dp[i][j] = Math.max(dp[i][j], dp[i - num0][j - num1] + 1);
+                    }
+                }
+            }
+            return dp[m][n];
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/OnesAndZeroes.md

@@ -0,0 +1,38 @@
+<p>给你一个二进制字符串数组 <code>strs</code> 和两个整数 <code>m</code> 和 <code>n</code> 。</p>
+
+<div class="MachineTrans-Lines">
+<p class="MachineTrans-lang-zh-CN">请你找出并返回 <code>strs</code> 的最大子集的大小，该子集中 <strong>最多</strong> 有 <code>m</code> 个 <code>0</code> 和 <code>n</code> 个 <code>1</code> 。</p>
+
+<p class="MachineTrans-lang-zh-CN">如果 <code>x</code> 的所有元素也是 <code>y</code> 的元素，集合 <code>x</code> 是集合 <code>y</code> 的 <strong>子集</strong> 。</p>
+</div>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
+<strong>输出：</strong>4
+<strong>解释：</strong>最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
+其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>strs = ["10", "0", "1"], m = 1, n = 1
+<strong>输出：</strong>2
+<strong>解释：</strong>最大的子集是 {"0", "1"} ，所以答案是 2 。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= strs.length <= 600</code></li>
+	<li><code>1 <= strs[i].length <= 100</code></li>
+	<li><code>strs[i]</code> 仅由 <code>'0'</code> 和 <code>'1'</code> 组成</li>
+	<li><code>1 <= m, n <= 100</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>动态规划</li></div></div>\n<div><li>👍 481</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/RemoveLinkedListElements.java

@@ -0,0 +1,84 @@
+//给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：head = [1,2,6,3,4,5,6], val = 6
+//输出：[1,2,3,4,5]
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：head = [], val = 1
+//输出：[]
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：head = [7,7,7,7], val = 7
+//输出：[]
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 列表中的节点在范围 [0, 104] 内 
+// 1 <= Node.val <= 50 
+// 0 <= k <= 50 
+// 
+// Related Topics 链表 
+// 👍 613 👎 0
+
+package leetcode.editor.cn;
+
+import com.code.leet.entiy.ListNode;
+
+//203:移除链表元素
+class RemoveLinkedListElements{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new RemoveLinkedListElements().new Solution();
+    }
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeElements(ListNode head, int val) {
+        ListNode temp = head;
+        if (temp == null) {
+            return head;
+        }
+        while (temp.val == val) {
+            head = temp = temp.next;
+            if (temp == null) {
+                return head;
+            }
+        }
+        while (temp != null && temp.next != null) {
+            if (temp.next.val == val) {
+                temp.next = temp.next.next;
+            } else {
+                temp = temp.next;
+            }
+        }
+        return head;
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/RemoveLinkedListElements.md

@@ -0,0 +1,34 @@
+给你一个链表的头节点 <code>head</code> 和一个整数 <code>val</code> ，请你删除链表中所有满足 <code>Node.val == val</code> 的节点，并返回 <strong>新的头节点</strong> 。
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/06/removelinked-list.jpg" style="width: 500px; height: 142px;" />
+<pre>
+<strong>输入：</strong>head = [1,2,6,3,4,5,6], val = 6
+<strong>输出：</strong>[1,2,3,4,5]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>head = [], val = 1
+<strong>输出：</strong>[]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>head = [7,7,7,7], val = 7
+<strong>输出：</strong>[]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>列表中的节点在范围 <code>[0, 10<sup>4</sup>]</code> 内</li>
+	<li><code>1 <= Node.val <= 50</code></li>
+	<li><code>0 <= k <= 50</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>链表</li></div></div>\n<div><li>👍 613</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/RemoveLinkedListElements144362264.txt

@@ -0,0 +1,34 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeElements(ListNode head, int val) {
+        ListNode temp = head;
+        if (temp == null) {
+            return head;
+        }
+        while (temp.val == val) {
+            head = temp = temp.next;
+            if (temp == null) {
+                return head;
+            }
+        }
+        while (temp != null && temp.next != null) {
+            if (temp.next.val == val) {
+                temp.next = temp.next.next;
+            } else {
+                temp = temp.next;
+            }
+        }
+        return head;
+    }
+}
+//runtime:1 ms
+//memory:39.4 MB