weekly contest 391

Author: ZLBer

README.md

@@ -6,6 +6,7 @@ leetcode url: <https://leetcode.cn/u/cctest/>
 
 
 
+* 🐼 [weekly contest 391](src/main/java/weekly/wk391.java)     遍历 | 模拟 | 滑动窗口 | 数学
 * 🐼 [weekly contest 390](src/main/java/weekly/wk390.java)     滑动窗口 | 枚举 | 懒删除 | 字典树
 * 🐼 [weekly contest 387](src/main/java/weekly/wk387.java)     模拟 | 二维前缀和 | 模拟 | 树状数组
 * 🐼 [weekly contest 386](src/main/java/weekly/wk386.java)     遍历 | 贪心 | 二分 |  二分
@@ -93,7 +94,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 126](src/main/java/weekly/wkb126.java)   模拟 | 堆、排序 | 堆、贪心 | DP(背包)
+* 🐸 [biweekly contest 127](src/main/java/weekly/wkb127.java)   前缀和 | 滑动窗口 | 记忆化搜索
 * 🐸 [biweekly contest 125](src/main/java/weekly/wkb125.java)   遍历 | 堆 | 乘法原理 | 贪心、DP
 * 🐸 [biweekly contest 122](src/main/java/weekly/wkb122.java)   滑动窗口+双推 | 分组循环 | 贪心 | 滑动窗口+双堆
 * 🐸 [biweekly contest 121](src/main/java/weekly/wkb121.java)   遍历 | 贪心 | 异或 | 数位dp

src/main/java/weekly/wk391.java

@@ -0,0 +1,85 @@
+package weekly;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class wk391 {
+    // 遍历
+    public int sumOfTheDigitsOfHarshadNumber(int x) {
+        int num = x;
+        int ans = 0;
+        while (x > 0) {
+            ans += x % 10;
+            x /= 10;
+        }
+        return num % ans == 0 ? ans : -1;
+    }
+
+    //模拟
+    public int maxBottlesDrunk(int numBottles, int numExchange) {
+        int ans = numBottles;
+        while (true) {
+            if (numBottles >= numExchange) {
+                numBottles -= numExchange;
+                ans++;
+                numBottles += 1;
+                numExchange++;
+            } else {
+                return ans;
+            }
+        }
+    }
+
+    //遍历
+    public long countAlternatingSubarrays(int[] nums) {
+
+        long ans = 1;
+        int left = 0;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] == nums[i - 1]) {
+                left = i;
+            }
+            ans += (i - left + 1);
+        }
+        return ans;
+    }
+
+
+    //数学 切比雪夫
+    public int minimumDistance(int[][] points) {
+        TreeMap<Integer, Integer> xs = new TreeMap<>();
+        TreeMap<Integer, Integer> ys = new TreeMap<>();
+        for (int[] p : points) {
+            xs.merge(p[0] + p[1], 1, Integer::sum);
+            ys.merge(p[1] - p[0], 1, Integer::sum);
+        }
+        int ans = Integer.MAX_VALUE;
+        for (int[] p : points) {
+            int x = p[0] + p[1], y = p[1] - p[0];
+            if (xs.get(x) == 1) xs.remove(x);
+            else xs.merge(x, -1, Integer::sum);
+            if (ys.get(y) == 1) ys.remove(y);
+            else ys.merge(y, -1, Integer::sum);
+            ans = Math.min(ans, Math.max(xs.lastKey() - xs.firstKey(), ys.lastKey() - ys.firstKey()));
+            xs.merge(x, 1, Integer::sum);
+            ys.merge(y, 1, Integer::sum);
+        }
+        return ans;
+    }
+
+
+
+    public static void main(String[] args) {
+        wk391 w = new wk391();
+        w.minimumDistance(new int[][]{
+                {3, 10}, {5, 15}, {10, 2}, {4, 4}
+        });
+    }
+
+}

src/main/java/weekly/wkb127.java

@@ -0,0 +1,116 @@
+package weekly;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class wkb127 {
+
+
+    //前缀和
+    public int minimumLevels(int[] possible) {
+        int sum = 0;
+        for (int i = 0; i < possible.length; i++) {
+            if (possible[i] == 1) {
+                sum++;
+            } else {
+                sum--;
+            }
+        }
+        int left = 0;
+        for (int i = 0; i < possible.length - 1; i++) {
+            if (possible[i] == 1) {
+                left++;
+            } else {
+                left--;
+            }
+            int right = sum - left;
+            if (left > right) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+
+
+    //滑动窗口
+    static public int minimumSubarrayLength(int[] nums, int k) {
+        int temp = 0;
+        int ans = Integer.MAX_VALUE;
+
+        int[] count = new int[32];
+        int left = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+            for (int j = 0; j <= 30; j++) {
+                if ((num & (1 << j)) > 0) {
+                    count[j]++;
+                }
+            }
+            temp |= nums[i];
+            while (temp >= k) {
+                ans = Math.min(ans, i - left + 1);
+                if (left >= i) break;
+                num = nums[left];
+                int delete = 0;
+                for (int j = 0; j <= 30; j++) {
+                    if ((num & (1 << j)) > 0) {
+                        count[j]--;
+                        if (count[j] == 0) {
+                            delete += (1 << j);
+                        }
+                    }
+                }
+
+                if (temp - delete >= k) {
+                    temp -= delete;
+                    left++;
+                } else {
+                    for (int j = 0; j <= 30; j++) {
+                        if ((num & (1 << j)) > 0) {
+                            count[j]++;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        return ans == Integer.MAX_VALUE ? -1 : ans;
+    }
+
+
+    int mod = (int) 1e9 + 7;
+
+    int inf = -mod;
+
+    //记忆化搜索
+    public int sumOfPowers(int[] nums, int k) {
+
+        Arrays.sort(nums);
+        memo = new HashMap[nums.length][k];
+        return dfs(nums, k, inf, 0, 0, Integer.MAX_VALUE);
+    }
+
+    HashMap<String, Integer>[][] memo;
+
+    int dfs(int[] nums, int k, int pre, int i, int j, int diff) {
+        if (j >= k) return diff;
+        if (i >= nums.length) {
+            return 0;
+        }
+        String key = pre + "_" + diff;
+        if (memo[i][j] != null && memo[i][j].containsKey(key)) return memo[i][j].get(key);
+        int res1 = dfs(nums, k, pre, i + 1, j, diff);
+        int res2 = dfs(nums, k, nums[i], i + 1, j + 1, Math.min(nums[i] - pre, diff));
+        if (memo[i][j] == null) memo[i][j] = new HashMap<>();
+        int res = (res1 + res2) % mod;
+        memo[i][j].put(key, res);
+        return res;
+    }
+
+
+    public static void main(String[] args) {
+        wkb127 w = new wkb127();
+        w.sumOfPowers(new int[]{1, 2, 3, 4}, 3);
+    }
+}