Lcp春季赛

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/leetcode/editor/cn/SumListsLcci.java

@@ -44,7 +44,7 @@ public class SumListsLcci {
      * }
      */
     class Solution {
-        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+                public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
             int sum = 0;
             ListNode head = l1;
             ListNode temp = null;

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