Merge remote-tracking branch 'origin/master'

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

LeetCode/src/main/java/com/code/leet/week/Lcp20210410.java

@@ -0,0 +1,137 @@
+package com.code.leet.week;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+/**
+ * @Author: 轩辕龙儿
+ * @Date: 2021/4/10 15:07
+ * @Description:
+ */
+public class Lcp20210410 {
+    public int storeWater(int[] bucket, int[] vat) {
+        List<Integer> list = new ArrayList<>();
+        int count = 0;
+        int size = bucket.length;
+        for (int i = 0; i < size; i++) {
+            if (bucket[i] == 0) {
+                count++;
+                list.add(vat[i]);
+            } else {
+                list.add(vat[i] / bucket[i]);
+            }
+        }
+
+        return 0;
+    }
+
+    public static void main(String[] args) {
+        Lcp20210410 test = new Lcp20210410();
+//        System.out.println(test.maxGroupNumber(new int[]{2, 2, 2, 3, 4}));
+        System.out.println(test.electricCarPlan(new int[][]{{0, 4, 2}, {4, 3, 5}, {3, 0, 5}, {0, 1, 5}, {3, 2, 4}, {1, 2, 8}}, 8,
+                0, 2, new int[]{4, 1, 1, 3, 2}));
+    }
+
+    public int maxGroupNumber(int[] tiles) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int min = Integer.MAX_VALUE;
+        int max = -1;
+        for (int num : tiles) {
+            min = Math.min(min, num);
+            max = Math.max(max, num);
+            map.put(num, map.containsKey(num) ? map.get(num) + 1 : 1);
+        }
+        int count = 0;
+        int l0 = 0;
+        int l1 = map.get(min);
+        int l2 = map.getOrDefault(min + 1, 0);
+        int cur;
+        for (int i = min + 2; i <= max; i++) {
+            if (!map.containsKey(i)) {
+                count += l0 / 3 + l1 / 3 + l2 / 3;
+                l0 = l1 % 3;
+                l1 = l2 % 3;
+                l2 = 0;
+                continue;
+            }
+            cur = map.get(i);
+            if (l1 > 0 && l2 > 0) {
+                int tempMin = Math.min(cur, Math.min(l1, l2));
+                int tempCount = l1 / 3 + l2 / 3 + cur / 3;
+                if (tempMin >= tempCount) {
+                    count += tempMin;
+                    l0 = l1 - tempMin;
+                    l1 = l2 - tempMin;
+                    l2 = cur - tempMin;
+                } else {
+                    count += l1 / 3;
+                    l0 = l1 % 3;
+                    l1 = l2;
+                    l2 = cur;
+                }
+            } else {
+                count += l0 / 3 + l1 / 3;
+                l0 = l1 % 3;
+                l1 = l2;
+                l2 = cur;
+            }
+        }
+        return count + l1 / 3 + l2 / 3;
+    }
+
+    public int electricCarPlan(int[][] paths, int cnt, int start, int end, int[] charge) {
+        int arrSize = charge.length;
+        int[][] edges = new int[arrSize][arrSize];
+        int size = paths.length;
+        for (int i = 0; i < arrSize; i++) {
+            for (int j = 0; j < arrSize; j++) {
+                edges[i][j] = i == j ? 0 : Integer.MAX_VALUE;
+            }
+        }
+        int[] distance = new int[arrSize];
+        for (int i = 0; i < arrSize; i++) {
+            distance[i] = i == start ? 0 : Integer.MAX_VALUE;
+        }
+        for (int i = 0; i < size; i++) {
+            int num1 = paths[i][0];
+            int num2 = paths[i][1];
+            int tempLength = paths[i][2];
+            edges[num1][num2] = tempLength * (charge[num1] + 1);
+            edges[num2][num1] = tempLength * (charge[num2] + 1);
+            if (num1 == start) {
+                distance[num2] = edges[num1][num2];
+            }
+        }
+        boolean[] st = new boolean[arrSize];
+        // 处理从源点到其余顶点的最短路径
+        for (int i = 0; i < arrSize; ++i) {
+            int min = Integer.MAX_VALUE;
+            int index = -1;
+            // 比较从源点到其余顶点的路径长度
+            for (int j = 0; j < arrSize; ++j) {
+                // 从源点到j顶点的最短路径还没有找到
+                if (!st[j]) {
+                    // 从源点到j顶点的路径长度最小
+                    if (distance[j] < min) {
+                        index = j;
+                        min = distance[j];
+                    }
+                }
+            }
+            //找到源点到索引为index顶点的最短路径长度
+            if (index != -1) {
+                st[index] = true;
+            }
+            // 更新当前最短路径及距离
+            for (int w = 0; w < arrSize; w++) {
+                if (!st[w]) {
+                    if (edges[index][w] != Integer.MAX_VALUE
+                            && (min + edges[index][w] < distance[w])) {
+                        distance[w] = min + edges[index][w];
+                    }
+                }
+            }
+        }
+        return distance[end];
+    }
+}

LeetCode/src/main/java/com/code/leet/week/LcpSolution.java

@@ -11,11 +11,11 @@ import java.util.stream.Collectors;
 public class LcpSolution {
     public static void main(String[] args) {
         LcpSolution solution = new LcpSolution();
-        System.out.println(solution.orchestraLayout(4, 1, 2));
+//        System.out.println(solution.orchestraLayout(4, 1, 2));
 
-//        int[] nums = {2, 2, 1, 9};
+        int[] nums = {2, 2, 3, 5};
-//        int target = 10;
+        int target = 6;
-//        System.out.println(solution.purchasePlans(nums, target));
+        System.out.println(solution.purchasePlans(nums, target));
     }
 
     public int magicTower(int[] nums) {
@@ -67,34 +67,56 @@ public class LcpSolution {
         return result % 9;
     }
 
+    //    public int purchasePlans(int[] nums, int target) {
+//        long count = 0;
+//        List<Integer> numList = Arrays.stream(nums).boxed().collect(Collectors.toList());
+//        Collections.sort(numList);
+//        Map<Integer, Long> map = new HashMap<>();
+//        int temp = -1;
+//        for (int num : numList) {
+//            if (num >= target) {
+//                break;
+//            }
+//            if (temp == -1) {
+//                for (int i = 1; i < num; i++) {
+//                    map.put(i, Long.parseLong("0"));
+//                }
+//                map.put(num, Long.parseLong("1"));
+//            } else {
+//                if (map.containsKey(target - num)) {
+//                    count += map.get(target - num);
+//                } else {
+//                    count += map.get(temp);
+//                }
+//                for (int i = temp + 1; i < num; i++) {
+//                    map.put(i, map.get(temp));
+//                }
+//                map.put(num, map.get(temp) + 1);
+//            }
+//            temp = num;
+//        }
+//        return (int) (count % (Math.pow(10, 9) + 7));
+//    }
     public int purchasePlans(int[] nums, int target) {
-        long count = 0;
+        int[] sort = new int[target];
-        List<Integer> numList = Arrays.stream(nums).boxed().collect(Collectors.toList());
+        long[] count = new long[target];
-        Collections.sort(numList);
+        for (int num : nums) {
-        Map<Integer, Long> map = new HashMap<>();
+            if (num < target) {
-        int temp = -1;
+                sort[num] += 1;
-        for (int num : numList) {
-            if (num >= target) {
-                break;
             }
-            if (temp == -1) {
-                for (int i = 1; i < num; i++) {
-                    map.put(i, Long.parseLong("0"));
         }
-                map.put(num, Long.parseLong("1"));
+        long sum = 0;
-            } else {
+        for (int i = 1; i < target; i++) {
-                if (map.containsKey(target - num)) {
+            sum += sort[i];
-                    count += map.get(target - num);
+            count[i] = sum;
-                } else {
-                    count += map.get(temp);
         }
-                for (int i = temp + 1; i < num; i++) {
+        long result = 0;
-                    map.put(i, map.get(temp));
+        for (int num : nums) {
+            if (target > num) {
+                result += num <= target - num ? count[target - num] - 1 : count[target - num];
             }
-                map.put(num, map.get(temp) + 1);
         }
-            temp = num;
+        Calendar calendar = Calendar.getInstance();
-        }
+        return (int) (result / 2 % (Math.pow(10, 9) + 7));
-        return (int) (count % (Math.pow(10, 9) + 7));
     }
 }

LeetCode/src/main/java/leetcode/editor/cn/AddTwoNumbersIi.java

@@ -0,0 +1,51 @@
+//给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 
+//
+// 你可以假设除了数字 0 之外，这两个数字都不会以零开头。 
+//
+// 
+//
+// 进阶： 
+//
+// 如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。 
+//
+// 
+//
+// 示例： 
+//
+// 输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+//输出：7 -> 8 -> 0 -> 7
+// 
+// Related Topics 链表 
+// 👍 368 👎 0
+
+package leetcode.editor.cn;
+
+import com.code.leet.entiy.ListNode;
+
+//445:两数相加 II
+public class AddTwoNumbersIi {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new AddTwoNumbersIi().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 addTwoNumbers(ListNode l1, ListNode l2) {
+            return null;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

LeetCode/src/main/java/leetcode/editor/cn/MergeSortedArray.java

@@ -0,0 +1,79 @@
+//给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。 
+//
+// 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nu
+//ms2 的元素。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+//输出：[1,2,2,3,5,6]
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：nums1 = [1], m = 1, nums2 = [], n = 0
+//输出：[1]
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// nums1.length == m + n 
+// nums2.length == n 
+// 0 <= m, n <= 200 
+// 1 <= m + n <= 200 
+// -109 <= nums1[i], nums2[i] <= 109 
+// 
+// Related Topics 数组 双指针 
+// 👍 880 👎 0
+
+package leetcode.editor.cn;
+
+//88:合并两个有序数组
+public class MergeSortedArray {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MergeSortedArray().new Solution();
+        int[] nums1 = new int[]{1, 2, 3, 0, 0, 0};
+        int[] nums2 = new int[]{2, 5, 6};
+        solution.merge(nums1, 3, nums2, 3);
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public void merge(int[] nums1, int m, int[] nums2, int n) {
+            int i = 0, j = 0;
+            if (m == 0) {
+                nums1 = nums2;
+                return;
+            }
+            if (n == 0) {
+                return;
+            }
+            while (j < n) {
+                if (i >= m) {
+                    nums1[i] = nums2[j];
+                    j++;
+                } else if (nums1[i] > nums2[j]) {
+                    if (m - i - i >= 0) {
+                        if (m + n - 1 - i - i >= 0) {
+                            System.arraycopy(nums1, i, nums1, i + 1, m + n - 1 - i - i);
+                        }
+                    }
+                    nums1[i] = nums2[j];
+                    j++;
+                }
+                i++;
+            }
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

LeetCode/src/main/java/leetcode/editor/cn/MergeSortedArray.md

@@ -0,0 +1,32 @@
+<p>给你两个有序整数数组 <code>nums1</code><em> </em>和 <code>nums2</code>，请你将 <code>nums2</code><em> </em>合并到 <code>nums1</code><em> </em>中<em>，</em>使 <code>nums1</code><em> </em>成为一个有序数组。</p>
+
+<p>初始化 <code>nums1</code> 和 <code>nums2</code> 的元素数量分别为 <code>m</code> 和 <code>n</code><em> </em>。你可以假设 <code>nums1</code><em> </em>的空间大小等于 <code>m + n</code>，这样它就有足够的空间保存来自 <code>nums2</code> 的元素。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+<strong>输出：</strong>[1,2,2,3,5,6]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums1 = [1], m = 1, nums2 = [], n = 0
+<strong>输出：</strong>[1]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>nums1.length == m + n</code></li>
+	<li><code>nums2.length == n</code></li>
+	<li><code>0 <= m, n <= 200</code></li>
+	<li><code>1 <= m + n <= 200</code></li>
+	<li><code>-10<sup>9</sup> <= nums1[i], nums2[i] <= 10<sup>9</sup></code></li>
+</ul>
+<div><div>Related Topics</div><div><li>数组</li><li>双指针</li></div></div>\n<div><li>👍 880</li><li>👎 0</li></div>

LeetCode/src/main/java/leetcode/editor/cn/SumListsLcci.md

@@ -0,0 +1,22 @@
+<p>给定两个用链表表示的整数，每个节点包含一个数位。</p>
+
+<p>这些数位是反向存放的，也就是个位排在链表首部。</p>
+
+<p>编写函数对这两个整数求和，并用链表形式返回结果。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例：</strong></p>
+
+<pre><strong>输入：</strong>(7 -&gt; 1 -&gt; 6) + (5 -&gt; 9 -&gt; 2)，即617 + 295
+<strong>输出：</strong>2 -&gt; 1 -&gt; 9，即912
+</pre>
+
+<p><strong>进阶：</strong>思考一下，假设这些数位是正向存放的，又该如何解决呢?</p>
+
+<p><strong>示例：</strong></p>
+
+<pre><strong>输入：</strong>(6 -&gt; 1 -&gt; 7) + (2 -&gt; 9 -&gt; 5)，即617 + 295
+<strong>输出：</strong>9 -&gt; 1 -&gt; 2，即912
+</pre>
+<div><div>Related Topics</div><div><li>链表</li><li>数学</li></div></div>\n<div><li>👍 61</li><li>👎 0</li></div>

LeetCode/src/main/java/leetcode/editor/cn/SumListsLcci157362186.txt

@@ -0,0 +1,49 @@
+
+    /**
+     * Definition for singly-linked list.
+     * public class ListNode {
+     * int val;
+     * ListNode next;
+     * ListNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+            int sum = 0;
+            ListNode head = l1;
+            ListNode temp = null;
+            while (l1 != null && l2 != null) {
+                sum += l1.val + l2.val;
+                l1.val = sum % 10;
+                sum = sum / 10;
+                if (l1.next == null) {
+                    temp = l1;
+                }
+                l1 = l1.next;
+                l2 = l2.next;
+            }
+            while (l1 != null) {
+                sum += l1.val;
+                l1.val = sum % 10;
+                sum = sum / 10;
+                if (l1.next == null) {
+                    temp = l1;
+                }
+                l1 = l1.next;
+            }
+            while (l2 != null && temp != null) {
+                sum += l2.val;
+                temp.next = new ListNode(sum % 10);
+                sum = sum / 10;
+                temp = temp.next;
+                l2 = l2.next;
+            }
+            if (sum > 0) {
+                temp.next = new ListNode(sum);
+            }
+            return head;
+        }
+    }
+
+//runtime:2 ms
+//memory:38.9 MB

LeetCode/src/main/java/leetcode/editor/cn/UglyNumber.java

@@ -0,0 +1,78 @@
+//给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。 
+//
+// 丑数 就是只包含质因数 2、3 和/或 5 的正整数。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：n = 6
+//输出：true
+//解释：6 = 2 × 3 
+//
+// 示例 2： 
+//
+// 
+//输入：n = 8
+//输出：true
+//解释：8 = 2 × 2 × 2
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：n = 14
+//输出：false
+//解释：14 不是丑数，因为它包含了另外一个质因数 7 。
+// 
+//
+// 示例 4： 
+//
+// 
+//输入：n = 1
+//输出：true
+//解释：1 通常被视为丑数。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// -231 <= n <= 231 - 1 
+// 
+// Related Topics 数学 
+// 👍 221 👎 0
+
+package leetcode.editor.cn;
+
+//263:丑数
+public class UglyNumber {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new UglyNumber().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public boolean isUgly(int n) {
+            if (n <= 0) {
+                return false;
+            }
+            while (n % 5 == 0) {
+                n = n / 5;
+            }
+            while (n % 3 == 0) {
+                n = n / 3;
+            }
+            while (n % 2 == 0) {
+                n = n / 2;
+            }
+            return n == 1;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

LeetCode/src/main/java/leetcode/editor/cn/UglyNumber.md

@@ -0,0 +1,45 @@
+<p>给你一个整数 <code>n</code> ，请你判断 <code>n</code> 是否为 <strong>丑数</strong> 。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
+
+<p><strong>丑数 </strong>就是只包含质因数 <code>2</code>、<code>3</code> 和/或 <code>5</code> 的正整数。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 6
+<strong>输出：</strong>true
+<strong>解释：</strong>6 = 2 × 3</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 8
+<strong>输出：</strong>true
+<strong>解释：</strong>8 = 2 × 2 × 2
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 14
+<strong>输出：</strong>false
+<strong>解释：</strong>14 不是丑数，因为它包含了另外一个质因数 <code>7 </code>。
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 1
+<strong>输出：</strong>true
+<strong>解释：</strong>1 通常被视为丑数。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>数学</li></div></div>\n<div><li>👍 221</li><li>👎 0</li></div>

LeetCode/src/main/java/leetcode/editor/cn/doc/java-by-pluto1314-y7xn.md

@@ -0,0 +1,60 @@
+### 解题思路
+执行用时：2 ms, 在所有 Java 提交中击败了100.00%的用户
+内存消耗：39 MB, 在所有 Java 提交中击败了9.73%的用户
+
+### 代码
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode res = new ListNode(0);
+        ListNode helper = res;
+        int temp = 0;
+        int up = 0;
+
+        while (l1 != null && l2 != null) {
+            int sum = l1.val + l2.val + up;
+            if ( sum > 9) {
+                temp = sum - 10;
+                up = 1;
+            } else {
+                temp = sum;
+                up = 0;
+            }
+            helper.next = new ListNode(temp);
+            helper = helper.next;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+
+        ListNode helper2 = l1 == null ? l2 : l1;
+        while (helper2 != null) {
+            int sum = helper2.val + up;
+            if ( sum > 9) {
+                temp = sum - 10;
+                up = 1;
+            } else {
+                temp = sum;
+                up = 0;
+            }
+            helper.next = new ListNode(temp);
+            helper = helper.next;
+            helper2 = helper2.next;
+        }
+
+        if (up == 1) {
+            helper.next = new ListNode(up);
+            helper = helper.next;
+        }
+        return res.next;
+    }
+}
+```