weekly contest 359

Author: ZLBer

README.md

@@ -4,6 +4,7 @@ Record leetcode contest and ideas every week, and encourage yourself to think mo
 
 leetcode url: <https://leetcode.cn/u/cctest/>
 
+* 🐼 [weekly contest 359](src/main/java/weekly/wk359.java)     模拟 | 贪心 | 分组+dp | 分组+双指针
 * 🐼 [weekly contest 358](src/main/java/weekly/wk358.java)     模拟 | 链表 | 滑动窗口 | 质数分解+单调栈+快速幂
 * 🐼 [weekly contest 357](src/main/java/weekly/wk357.java)     模拟 | 贪心 | 并查集、Dijkstra | 贪心
 * 🐼 [weekly contest 356](src/main/java/weekly/wk356.java)     遍历 | 滑动窗口 | 枚举 | 数位dp
@@ -69,6 +70,7 @@ leetcode url: <https://leetcode.cn/u/cctest/>
 * 🐭 [weekly contest 280](src/main/java/weekly/wk289.java)
 
 
+* 🐸 [biweekly contest 111](src/main/java/weekly/wkb111.java)   遍历 | 贪心+双指针 | 前缀和、dp | 数位dp
 * 🐸 [biweekly contest 110](src/main/java/weekly/wkb110.java)   遍历 | 链表 | 哈希 | 排序+dp
 * 🐸 [biweekly contest 109](src/main/java/weekly/wkb109.java)   模拟 | 模拟 | dp | 01背包/记忆化搜索
 * 🐸 [biweekly contest 108](src/main/java/weekly/wkb108.java)   模拟 | 哈希 | dp | 枚举

src/main/java/weekly/wk359.java

@@ -0,0 +1,113 @@
+package weekly;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+public class wk359 {
+    //模拟
+    public boolean isAcronym(List<String> words, String s) {
+        if (words.size() != s.length()) return false;
+        for (int i = 0; i < words.size(); i++) {
+            if (words.get(i).charAt(0) != s.charAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //贪心
+    public int minimumSum(int n, int k) {
+        Set<Integer> set = new HashSet<>();
+
+        int num = 1;
+        int sum = 0;
+        for (int i = 0; i < n; i++) {
+            while (set.contains(k - num)) {
+                num++;
+            }
+            set.add(num);
+            sum += num;
+            num++;
+        }
+
+        return sum;
+    }
+
+
+    // n*logn
+    // 堆
+/*    public int maximizeTheProfit(int n, List<List<Integer>> offers) {
+        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
+        Collections.sort(offers, (a, b) -> a.get(1) - b.get(1));
+
+        int ans = 0;
+        for (List<Integer> offer : offers) {
+            int start = offer.get(0);
+            int end = offer.get(1);
+            int gold = offer.get(2);
+            Map.Entry<Integer, Integer> pre = treeMap.floorEntry(start - 1);
+            Map.Entry<Integer, Integer> entry = treeMap.floorEntry(end);
+            int val = Math.max((pre == null ? 0 : pre.getValue()) + gold, entry == null ? 0 : entry.getValue());
+            treeMap.put(end, val);
+            ans = Math.max(ans, val);
+        }
+
+        return ans;
+    }*/
+
+    //分组+dp
+    public int maximizeTheProfit(int n, List<List<Integer>> offers) {
+        ArrayList<int[]>[] groups = new ArrayList[n];
+        Arrays.setAll(groups, e -> new ArrayList<>());
+        for (List<Integer> offer : offers) {
+            groups[offer.get(1)].add(new int[]{offer.get(0), offer.get(2)});
+        }
+        int[] dp = new int[n + 1];
+
+        for (int end = 0; end <= n; end++) {
+            dp[end + 1] = dp[end];
+            for (int[] ints : groups[end]) {
+                dp[end + 1] = Math.max(dp[end + 1], dp[ints[0]] + ints[1]);
+            }
+        }
+
+        return dp[n];
+    }
+
+
+    // n* log n
+    //分组+双指针
+    public int longestEqualSubarray(List<Integer> nums, int k) {
+        Map<Integer, Deque<Integer>> map = new HashMap<>();
+
+        int ans = 1;
+        for (int i = 0; i < nums.size(); i++) {
+            int num = nums.get(i);
+            if (!map.containsKey(num)) {
+                map.put(num, new ArrayDeque<>());
+                map.get(num).addLast(i);
+            } else {
+                Deque<Integer> list = map.get(num);
+                list.addLast(i);
+                int count = list.size();
+                while (i - list.peekFirst() + 1 - count > k) {
+                    list.pollFirst();
+                    count--;
+                }
+                ans = Math.max(ans, list.size());
+            }
+        }
+        return ans;
+    }
+
+
+}

src/main/java/weekly/wkb111.java

@@ -0,0 +1,123 @@
+package weekly;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+public class wkb111 {
+    //遍历
+    public int countPairs(List<Integer> nums, int target) {
+        int ans = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            for (int j = i + 1; j < nums.size(); j++) {
+                if (nums.get(i) + nums.get(j) < target) {
+                    ans++;
+                }
+            }
+        }
+        return ans;
+    }
+
+    //贪心+双指针
+    public boolean canMakeSubsequence(String str1, String str2) {
+        int index = 0;
+        for (int i = 0; i < str1.length() && index < str2.length(); i++) {
+            char c = str1.charAt(i);
+            if (c == str2.charAt(index)) {
+                index++;
+            } else if (c == 'z' && str2.charAt(index) == 'a') {
+                index++;
+            } else if ((char) (c + 1) == str2.charAt(index)) {
+                index++;
+            }
+        }
+        return index >= str2.length();
+    }
+
+    //前缀和或dp
+    public int minimumOperations(List<Integer> nums) {
+        int[][] count = new int[nums.size() + 1][3];
+        for (int i = 0; i < nums.size(); i++) {
+            count[i + 1] = new int[]{
+                    count[i][0], count[i][1], count[i][2]
+            };
+            if (nums.get(i) == 1) {
+                count[i + 1][0]++;
+            } else if (nums.get(i) == 2) {
+                count[i + 1][1]++;
+            } else if (nums.get(i) == 3) {
+                count[i + 1][2]++;
+            }
+        }
+
+        int ans = Math.min(nums.size() - count[nums.size()][0], Math.min(nums.size() - count[nums.size()][1], nums.size() - count[nums.size()][2]));
+        for (int i = 0; i <= nums.size(); i++) {
+            for (int j = i; j <= nums.size(); j++) {
+                int one = i - count[i][0];
+                int two = (j - i) - (count[j][1] - count[i][1]);
+                int three = (nums.size() - j) - (count[nums.size()][2] - count[j][2]);
+                ans = Math.min(ans, one + two + three);
+            }
+        }
+
+        return ans;
+    }
+
+
+    //数位dp
+    public int numberOfBeautifulIntegers(int low, int high, int k) {
+        this.k = k;
+        return countSpecialNumbers(high) - countSpecialNumbers(low-1) ;
+    }
+
+    //数位dp通用模板
+
+    char s[];
+    int dp[][][];
+    int k;
+
+    public int countSpecialNumbers(int n) {
+        s = Integer.toString(n).toCharArray();
+        int m = s.length;
+        dp = new int[m][100][21];
+        for (int i = 0; i < m; i++)
+            for (int j = 0; j < dp[0].length; j++) {
+                Arrays.fill(dp[i][j], -1);
+            }
+        return f(0, 0, 0, true, false);
+    }
+
+    //i表示当前位置，mask 奇数和偶数的数目，islimit表示是否限制最大到9，isNum表示之前是否有数字
+    int f(int i, int mask, int mod, boolean isLimit, boolean isNum) {
+        if (i == s.length) {
+            boolean b = isNum && mod == 0 && (mask / 10) == (mask % 10);
+            if (b) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+        if (!isLimit && isNum && dp[i][mask][mod] >= 0) return dp[i][mask][mod];
+        int res = 0;
+        if (!isNum) res = f(i + 1, mask,mod, false, false); // 可以跳过当前数位
+        for (int d = isNum ? 0 : 1, up = isLimit ? s[i] - '0' : 9; d <= up; ++d) { // 枚举要填入的数字 d
+            int add = 0;
+            if (d % 2 == 0) {
+                add = 10;
+            } else {
+                add = 1;
+            }
+
+            res += f(i + 1, mask + add, (mod * 10 + d)%k,isLimit && d == up, true);
+        }
+        if (!isLimit && isNum) dp[i][mask][mod] = res;
+        return res;
+    }
+
+
+    public static void main(String[] args) {
+        wkb111 w = new wkb111();
+        System.out.println(w.numberOfBeautifulIntegers(0, 72, 16));
+    }
+
+}