weekly contest 390

Author: ZLBer

README.md

@@ -6,6 +6,7 @@ leetcode url: <https://leetcode.cn/u/cctest/>
 
 
 
+* 🐼 [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)     遍历 | 贪心 | 二分 |  二分
 * 🐼 [weekly contest 382](src/main/java/weekly/wk382.java)     遍历 | 枚举 | 数学 |  贪心
@@ -92,7 +93,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 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/wk389.java

@@ -0,0 +1,84 @@
+package weekly;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class wk389 {
+
+    // 模拟
+    public boolean isSubstringPresent(String s) {
+        Set<String> list = new HashSet<>();
+        for (int i = 0; i < s.length() - 1; i++) {
+            list.add(s.substring(i, i + 2));
+        }
+        String sb = new StringBuilder(s).reverse().toString();
+        for (int i = 0; i < sb.length() - 1; i++) {
+            if (list.contains(sb.substring(i, i + 2))) {
+                return true;
+            }
+        }
+        return false;
+
+    }
+
+
+    //前缀和 数学
+    public long countSubstrings(String s, char c) {
+        int[] count = new int[s.length() + 1];
+        for (int i = 0; i < s.length(); i++) {
+            count[i + 1] = count[i];
+            if (s.charAt(i) == c) {
+                count[i + 1]++;
+            }
+        }
+
+        long ans = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == c) {
+                int left = count[i];
+                int right = count[s.length()] - left;
+                ans += right;
+            }
+
+        }
+        return ans;
+    }
+
+    //
+   static public int minimumDeletions(String word, int k) {
+        int[] count = new int[26];
+        for (int i = 0; i < word.length(); i++) {
+            count[word.charAt(i) - 'a']++;
+        }
+
+        Arrays.sort(count);
+       int[] pre = new int[count.length + 1];
+       for (int i = 0; i < count.length; i++) {
+           pre[i + 1] = count[i] + pre[i];
+       }
+        int i = 0;
+        while (count[i] == 0) {
+            i++;
+        }
+        int ans = Integer.MAX_VALUE;
+        for (; i < count.length; i++) {
+            if (i > 0 && count[i] == count[i - 1]) continue;
+            int del = 0;
+            for (int j = i + 1; j < count.length; j++) {
+                if (count[j] - count[i] > k) {
+                    del += count[j] - count[i] - k;
+                }
+            }
+            del += pre[i];
+            ans = Math.min(ans, del);
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        minimumDeletions("aabcaba",0);
+    }
+}

src/main/java/weekly/wk390.java

@@ -0,0 +1,123 @@
+package weekly;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.TreeMap;
+
+public class wk390 {
+    //滑动窗口
+    public int maximumLengthSubstring(String s) {
+        int[] count = new int[26];
+        int left = 0;
+        int ans = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            count[c - 'a']++;
+
+            while (count[c - 'a'] > 2) {
+                count[s.charAt(left++) - 'a']--;
+            }
+            ans = Math.max(ans, i - left + 1);
+        }
+        return ans;
+    }
+
+    //枚举k
+    public int minOperations(int k) {
+        int ans = k - 1;
+        for (int i = 1; i <= k; i++) {
+            int tmp = (i - 1);
+            tmp += (k / i - 1) + (k % i > 0 ? 1 : 0);
+            ans = Math.min(ans, tmp);
+        }
+        return ans;
+    }
+
+
+    //懒删除
+    static public long[] mostFrequentIDs(int[] nums, int[] freq) {
+        Map<Long, Long> map = new HashMap<>();
+        PriorityQueue<long[]> priorityQueue = new PriorityQueue<>((a, b) -> -Long.compare(a[0], b[0]));
+        long[] ans = new long[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            long num = nums[i];
+            Long count = map.getOrDefault(num, 0L) + freq[i];
+            map.put(num, count);
+            priorityQueue.add(new long[]{count, num});
+
+            while (map.get(priorityQueue.peek()[1]) != priorityQueue.peek()[0]) {
+                priorityQueue.poll();
+            }
+            ans[i] = priorityQueue.peek()[0];
+        }
+        return ans;
+    }
+
+
+    //字典树
+    public int[] stringIndices(String[] wordsContainer, String[] wordsQuery) {
+        Trie t = new Trie();
+        for (int i = 0; i < wordsContainer.length; i++) {
+            t.insert(wordsContainer[i], i);
+        }
+        int[] ans = new int[wordsQuery.length];
+        for (int i = 0; i < wordsQuery.length; i++) {
+            ans[i] = t.search(wordsQuery[i]);
+        }
+        return ans;
+    }
+
+    class Trie {
+        Trie[] children;
+        int maxIndex = -1;
+        int minLen = Integer.MAX_VALUE;
+
+        public Trie() {
+            children = new Trie[26];
+        }
+
+        public void insert(String word, int wIndex) {
+            Trie cur = this;
+            if (word.length() < cur.minLen) {
+                cur.minLen = word.length();
+                cur.maxIndex = wIndex;
+            }
+            Trie[] branches = cur.children;
+            char[] chs = word.toCharArray();
+            for (int i = chs.length - 1; i >= 0; i--) {
+                int index = chs[i] - 'a';
+                if (branches[index] == null) {
+                    branches[index] = new Trie();
+                }
+                cur = branches[index];
+                branches = cur.children;
+                if (word.length() < cur.minLen) {
+                    cur.minLen = word.length();
+                    cur.maxIndex = wIndex;
+                }
+            }
+        }
+
+        public int search(String word) {
+            Trie cur = this;
+            Trie[] branches = children;
+            char[] chs = word.toCharArray();
+            for (int i = chs.length - 1; i >= 0; i--) {
+                int index = chs[i] - 'a';
+                if (branches[index] != null) {
+                    cur = branches[index];
+                    branches = cur.children;
+                } else {
+                    return cur.maxIndex;
+                }
+            }
+            return cur.maxIndex;
+        }
+    }
+
+
+    public static void main(String[] args) {
+        mostFrequentIDs(new int[]{5, 5, 3}, new int[]{2, -2, 1});
+    }
+}

src/main/java/weekly/wkb126.java

@@ -0,0 +1,137 @@
+package weekly;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.Set;
+
+public class wkb126 {
+    //模拟
+    public int sumOfEncryptedInt(int[] nums) {
+
+        int ans = 0;
+        for (int num : nums) {
+            String s = num + "";
+            int max = 0;
+            for (int i = 0; i < s.length(); i++) {
+                int c = s.charAt(i) - '0';
+                max = Math.max(max, c);
+            }
+
+
+            int n = 0;
+            for (int i = 0; i < s.length(); i++) {
+                n = n * 10 + max;
+            }
+            ans += n;
+        }
+        return ans;
+    }
+
+
+    //排序or小根堆
+    public long[] unmarkedSumArray(int[] nums, int[][] queries) {
+
+        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
+
+        long sum = 0;
+        for (int i = 0; i < nums.length; i++) {
+            sum += nums[i];
+            priorityQueue.add(new int[]{nums[i], i});
+        }
+
+        Set<Integer> set = new HashSet<>();
+        long[] ans = new long[queries.length];
+
+        for (int j = 0; j < queries.length; j++) {
+            int[] query = queries[j];
+            int index = query[0];
+            int k = query[1];
+            if (!set.contains(index)) {
+                sum -= nums[index];
+                set.add(index);
+            }
+            for (int i = 0; i < k; i++) {
+                if (priorityQueue.isEmpty()) break;
+                int[] poll = priorityQueue.poll();
+                if (!set.contains(poll[1])) {
+                    sum -= poll[0];
+                    set.add(poll[1]);
+                } else {
+                    i--;
+                }
+            }
+            ans[j] = sum;
+        }
+        return ans;
+    }
+
+
+
+    // 小根堆/贪心
+    public String minimizeStringValue(String s) {
+
+        int need = 0;
+        int[] count = new int[26];
+        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
+        Arrays.fill(count, 0);
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == '?') {
+                need++;
+            } else {
+                count[s.charAt(i) - 'a']++;
+            }
+        }
+        for (int i = 0; i < count.length; i++) {
+            priorityQueue.add(new int[]{count[i], i});
+        }
+
+        List<Character> list = new ArrayList<>();
+        for (int i = 0; i < need; i++) {
+            int[] poll = priorityQueue.poll();
+            list.add((char) ('a' + poll[1]));
+            poll[0]++;
+            priorityQueue.add(poll);
+        }
+
+        Collections.sort(list);
+
+        int index = 0;
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == '?') {
+                sb.append(list.get(index++));
+            } else {
+                sb.append(s.charAt(i));
+            }
+        }
+        return sb.toString();
+    }
+
+
+    //dp
+    public int sumOfPower(int[] nums, int k) {
+        int mod = (int) 1e9 + 7;
+        int[] mem = new int[k + 1];
+        mem[0] = 1;
+        for (int num : nums) {
+            int[] nextMem = new int[k + 1];
+            for (int j = k; j >= 0; --j) {
+                // 子序列累计，加入or不加入两种
+                if (j - num >= 0) {
+                    nextMem[j] = ((2 * mem[j]) % mod + mem[j - num]) % mod;
+                } else {
+                    nextMem[j] = (2 * mem[j]) % mod;
+                }
+            }
+            mem = nextMem;
+        }
+        return mem[k];
+    }
+
+    public static void main(String[] args) {
+    }
+}