weekly contest 337

Author: ZLBer

README.md

@@ -5,7 +5,7 @@ Record leetcode contest and ideas every week, and encourage yourself to think mo
 leetcode url: <https://leetcode.cn/u/cctest/>
 
 
-
+* ☀️ [weekly contest 337](src/main/java/weekly/wk337.java)     模拟 | 模拟 | 回溯 | 同余分组
 * 🐎️ [weekly contest 336](src/main/java/weekly/wk336.java)     模拟 | 排序 | 异或前缀和 | 贪心
 * 🐎️ [weekly contest 335](src/main/java/weekly/wk335.java)     模拟 | 层序遍历 | 质数分解 | 多重背包
 * 🐎️ [weekly contest 334](src/main/java/weekly/wk334.java)     前缀和 | 取模 | 贪心 | Dijkstra
@@ -51,6 +51,7 @@ leetcode url: <https://leetcode.cn/u/cctest/>
 * 🐶 [weekly contest 290](src/main/java/weekly/wk290.java)
 * 🐭 [weekly contest 280](src/main/java/weekly/wk289.java)
 
+* 🐸 [biweekly contest 100](src/main/java/weekly/wkb100.java)   四维 | 贪心 | 堆 | 二分
 * 🐸 [biweekly contest 99](src/main/java/weekly/wkb99.java)   贪心 | 递推 | 区间合并 | 换根DP
 * 🐸 [biweekly contest 98](src/main/java/weekly/wkb98.java)   
 * 🐸 [biweekly contest 97](src/main/java/weekly/wkb97.java)   模拟 | 哈希 | 滑动窗口 | DFS

src/main/java/weekly/wk337.java

@@ -0,0 +1,107 @@
+package weekly;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+public class wk337 {
+
+
+    //模拟
+    public int[] evenOddBit(int n) {
+        int even = 0, odd = 0;
+        String s = Integer.toBinaryString(n);
+
+        for (int i = s.length() - 1; i >= 0; i--) {
+            if (s.charAt(i) == '1') {
+                if ((s.length() - i - 1) % 2 == 0) {
+                    even++;
+                } else {
+                    odd++;
+                }
+            }
+        }
+        return new int[]{even, odd};
+    }
+
+    //模拟
+    //可以打散成一维
+    public boolean checkValidGrid(int[][] grid) {
+        int[][] moves = new int[][]{
+                {1, 2}, {2, 1}, {-2, 1}, {1, -2},
+                {-1, 2}, {2, -1}, {-2, -1}, {-1, -2},
+        };
+
+        int x = 0, y = 0;
+        int cur = 0;
+        for (int i = 0; i < grid.length * grid[0].length - 1; i++) {
+            boolean flag = false;
+            for (int[] move : moves) {
+                int nx = move[0] + x;
+                int ny = move[1] + y;
+                if (nx >= 0 && ny >= 0 && nx < grid.length && ny < grid[0].length) {
+                    if (grid[nx][ny] == cur + 1) {
+                        x = nx;
+                        y = ny;
+                        cur++;
+                        flag = true;
+                        break;
+                    }
+                }
+
+            }
+            if (!flag) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //回溯
+    public int beautifulSubsets(int[] nums, int k) {
+        Arrays.sort(nums);
+        return help(new HashSet<>(),0,nums,k);
+    }
+
+    int help(Set<Integer> set, int index, int[] nums, int k) {
+
+        if (index >= nums.length) {
+            return 1;
+        }
+        int count = help(set,index+1,nums,k);
+        if (!set.contains(nums[index] - k)) {
+            set.add(nums[index]);
+            count += help(set, index + 1, nums, k);
+            set.remove(nums[index]);
+        }
+        return count;
+    }
+
+
+    //同余分组
+    public int findSmallestInteger(int[] nums, int value) {
+        int[] counter = new int[value];
+        for (int num : nums) {
+            int index = num % value;
+            if (index < 0) index += value;
+            counter[index]++;
+        }
+        int step = 0;
+        while (true) {
+            for (int i = 0; i < counter.length; i++) {
+                if (counter[i] == 0) {
+                    return value * step + i;
+                }
+                counter[i]--;
+            }
+            step++;
+        }
+    }
+
+    public static void main(String[] args) {
+
+    }
+}

src/main/java/weekly/wkb100.java

@@ -0,0 +1,123 @@
+package weekly;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.PriorityQueue;
+import java.util.Set;
+
+public class wkb100 {
+
+    //思维题？
+    public int distMoney(int money, int children) {
+        if (money < children) {
+            return -1;
+        }
+        int ans = 0;
+        for (int i = 0; i < children; i++) {
+            if (money >= 8) {
+                money -= 8;
+                ans++;
+            } else {
+                if (money == 4 && children - i == 1) {
+                    ans--;
+                } else if (money >= (children - i)) {
+
+                } else {
+                    int left = children - i - money;
+                    if (left != 0) {
+                        if (left % 7 == 0) {
+                            ans -= (left / 7);
+                        } else {
+                            ans -= (left / 7 + 1);
+                        }
+                    }
+                }
+                money = 0;
+                break;
+            }
+        }
+        if (money > 0) ans--;
+        return ans;
+    }
+
+
+    //贪心+排序
+    public int maximizeGreatness(int[] nums) {
+        Arrays.sort(nums);
+        int right = nums.length - 1;
+        int ans = 0;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            if (nums[right] > nums[i]) {
+                right--;
+                ans++;
+            }
+        }
+        return ans;
+    }
+
+
+    //优先队列
+    public long findScore(int[] nums) {
+        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
+        for (int i = 0; i < nums.length; i++) {
+            priorityQueue.add(new int[]{nums[i], i});
+        }
+
+        long ans = 0;
+        Set<Integer> set = new HashSet<>();
+        while (!priorityQueue.isEmpty()) {
+            int[] poll = priorityQueue.poll();
+            if (set.contains(poll[1])) {
+                continue;
+            }
+            set.add(poll[1] - 1);
+            set.add(poll[1] + 1);
+            ans += poll[0];
+        }
+
+        return ans;
+    }
+
+
+    // 优先队列
+    /*public long repairCars(int[] ranks, int cars) {
+        PriorityQueue<long[]> priorityQueue = new PriorityQueue<>((a, b) -> Long.compare(a[0], b[0]));
+        for (int rank : ranks) {
+            priorityQueue.add(new long[]{rank, 1, rank});
+        }
+        long ans = 0;
+        for (int i = 0; i < cars - 1; i++) {
+            long[] poll = priorityQueue.poll();
+            poll[1]++;
+            poll[0] = poll[2] * poll[1] * poll[1];
+            priorityQueue.add(poll);
+        }
+        return priorityQueue.poll()[0];
+    }*/
+
+    // 二分
+    public long repairCars(int[] ranks, int cars) {
+
+        long max = ranks[0];
+        for (int i : ranks) {
+            max = Math.min(max, i);
+        }
+        long left = 0;
+        long right = (long)cars * cars * max;
+        System.out.println(left + " " + right);
+        while (left < right) {
+            long mid = (left + right) / 2;
+            System.out.println(mid);
+            int s = 0;
+            for (int rank : ranks) {
+                s += Math.sqrt(mid / rank);
+            }
+            if (s >= cars) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}