weekly contest 349

Author: ZLBer

README.md

@@ -60,7 +60,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 106](src/main/java/weekly/wkb106.java)   模拟 | 滑动窗口 | 排序统计 | 贪心
 * 🐸 [biweekly contest 105](src/main/java/weekly/wkb105.java)   模拟 | 记忆化搜索 | 分类讨论 | 并查集
 * 🐸 [biweekly contest 102](src/main/java/weekly/wkb102.java)   模拟 | 前缀和 | bfs+dfs | Dijkstra
 * 🐸 [biweekly contest 101](src/main/java/weekly/wkb101.java)   哈希 | 滑动窗口 | 并查集 | BFS

src/main/java/weekly/wk349.java

@@ -0,0 +1,139 @@
+package weekly;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class wk349 {
+    //模拟
+    public int findNonMinOrMax(int[] nums) {
+        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+        for (int num : nums) {
+            min = Math.min(min, num);
+            max = Math.max(max, num);
+        }
+        for (int num : nums) {
+            if (num != min && num != max) {
+                return num;
+            }
+        }
+        return -1;
+    }
+
+    public String smallestString(String s) {
+        char[] chars = s.toCharArray();
+        int index = s.length();
+        //找到第一个不等于a的
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) != 'a') {
+                index = i;
+                break;
+            }
+        }
+        //若都是a，则也要替换一个
+        if (index == s.length()) {
+            chars[s.length() - 1] = 'z';
+            return new String(chars);
+        }
+        //碰到a就返回
+        for (int i = index; i < s.length(); i++) {
+            if (chars[i] == 'a') {
+                break;
+            } else {
+                chars[i] = (char) (chars[i] - 1);
+            }
+        }
+        return new String(chars);
+    }
+
+
+    //动态规划，考虑旋转n次
+    public long minCost(int[] nums, int x) {
+        //一次不转
+        long ans = 0;
+        for (int num : nums) {
+            ans += num;
+        }
+
+        int[] dp = new int[nums.length];
+        //一次不转就是原来的价格
+        for (int i = 0; i < nums.length; i++) {
+            dp[i] = nums[i];
+        }
+        //转d次
+        for (int d = 1; d < nums.length; d++) {
+            long temp = (long) d * x;
+            for (int i = 0; i < nums.length; i++) {
+                //比较最小的一次替换
+                dp[i] = Math.min(nums[(i + d) % nums.length], dp[i]);
+                temp += dp[i];
+            }
+            ans = Math.min(temp, ans);
+        }
+        return ans;
+    }
+
+
+    static public int[] maximumSumQueries(int[] nums1, int[] nums2, int[][] queries) {
+        int[][] comp = new int[nums1.length][4];
+        for (int i = 0; i < nums1.length; i++) {
+            comp[i] = new int[]{nums1[i], nums2[i]};
+        }
+        Arrays.sort(comp, (a, b) -> a[0] - b[0]);
+
+
+        int[][] qq = new int[queries.length][3];
+        for (int i = 0; i < queries.length; i++) {
+            qq[i] = new int[]{queries[i][0], queries[i][1], i};
+        }
+        Arrays.sort(qq, (a, b) -> b[0] - a[0]);
+        int[] ans = new int[queries.length];
+        int q = 0;
+        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
+        for (int i = comp.length - 1; i >= 0; i--) {
+            //查询的num1比这个要大，说明当前已不满足条件
+            while (q < queries.length && qq[q][0] > comp[i][0]) {
+                Map.Entry<Integer, Integer> entry = treeMap.ceilingEntry(qq[q][1]);
+                if (entry == null) {
+                    ans[qq[q][2]] = -1;
+                } else {
+                    ans[qq[q][2]] = entry.getValue();
+                }
+                q++;
+            }
+
+
+            int num2 = comp[i][1];
+            int max = num2 + comp[i][0];
+
+            //找一个比num2大的，继承其最大值
+            Map.Entry<Integer, Integer> up = treeMap.ceilingEntry(num2);
+            if (up != null) {
+                max = Math.max(up.getValue(), max);
+            }
+
+            //将比num2小的且和没有num2的大的都删除掉，即表示num2可以代表这些数了
+            while (treeMap.floorEntry(num2) != null && treeMap.floorEntry(num2).getValue() <= max) {
+                treeMap.remove(treeMap.floorKey(num2));
+            }
+            treeMap.put(num2, max);
+        }
+
+        while (q < queries.length) {
+            Map.Entry<Integer, Integer> entry = treeMap.ceilingEntry(qq[q][1]);
+            if (entry == null) {
+                ans[qq[q][2]] = -1;
+            } else {
+                ans[qq[q][2]] = entry.getValue();
+            }
+            q++;
+        }
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        maximumSumQueries(new int[]{4, 3, 1, 2}, new int[]{2, 4, 9, 5}, new int[][]{
+                {4, 1}, {1, 3}, {2, 5}
+        });
+    }
+}

src/main/java/weekly/wkb106.java

@@ -0,0 +1,144 @@
+package weekly;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class wkb106 {
+    //模拟
+    public boolean isFascinating(int n) {
+        int[] count = new int[10];
+        for (int i = 1; i <= 3; i++) {
+            String num = new String((n * i) + "");
+            for (char c : num.toCharArray()) {
+                count[c - '0']++;
+            }
+        }
+
+        if (count[0] > 0) return false;
+        for (int i = 1; i < count.length; i++) {
+            if (count[i] != 1) return false;
+        }
+        return true;
+    }
+/*
+    public int longestSemiRepetitiveSubstring(String s) {
+        char[] chars = s.toCharArray();
+        List<Integer> list = new ArrayList<>();
+        list.add(-1);
+        for (int i = 0; i < chars.length - 1; i++) {
+            if (chars[i] == chars[i + 1]) {
+                list.add(i);
+            }
+        }
+        list.add(s.length());
+        for (Integer integer : list) {
+            System.out.println(integer);
+        }
+        int ans = 0;
+        if (list.size() == 2) {
+            ans = s.length();
+        }
+        for (int i = 1; i < list.size() - 1; i++) {
+            ans = Math.max(ans, list.get(i + 1) - list.get(i - 1) + 1);
+        }
+        return ans;
+    }*/
+
+    //暴力
+   /* public int longestSemiRepetitiveSubstring(String s) {
+        int ans = 0;
+        for (int i = 0; i < s.length(); i++) {
+            for (int j = i; j < s.length(); j++) {
+                int count = 0;
+                for (int k = i + 1; k <= j; k++) {
+                    if (s.charAt(k) == s.charAt(k - 1)) {
+                        count++;
+                    }
+                }
+                if (count <= 1) {
+                    ans = Math.max(ans, j - i + 1);
+                }
+            }
+        }
+        return ans;
+    }*/
+    //滑动窗口
+    static public int longestSemiRepetitiveSubstring(String s) {
+        char[] chars = s.toCharArray();
+        int left = 0;
+        int same = 0;
+        int ans = 0;
+        for (int right = 1; right < chars.length; right++) {
+            if (chars[right] == chars[right - 1]) {
+                same++;
+                if (same > 1) {
+                    for (left++; chars[left] != chars[left - 1]; left++) {
+                        same = 1;
+                    }
+                }
+            }
+            ans = Math.max(ans, right - left + 1);
+        }
+        return ans;
+    }
+
+
+    //不管有没有碰撞，都是走d距离
+    public int sumDistance(int[] nums, String s, int d) {
+        int mod = (int) 1e9 + 7;
+        long[] distance = new long[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            if (s.charAt(i) == 'R') {
+                distance[i] = (long) nums[i] + d;
+            } else {
+                distance[i] = (long) nums[i] - d;
+            }
+        }
+//        for (int i = 0; i < nums.length; i++) {
+//            System.out.println(nums[i]);
+//        }
+        Arrays.sort(distance);
+
+        long sum = 0;
+        for (int i = 1; i < nums.length; i++) {
+            sum += distance[i] - distance[0];
+        }
+        long ans = 0;
+        ans += sum;
+        ans %= mod;
+        for (int i = 1; i < nums.length; i++) {
+            long dis = distance[i] - distance[i - 1];
+            sum -= (dis * (nums.length - i));
+            ans += sum;
+            ans %= mod;
+        }
+        return (int) ans;
+    }
+
+
+    //脑筋急转弯
+    public List<Integer> goodSubsetofBinaryMatrix(int[][] grid) {
+        Map<Integer, Integer> idx = new HashMap<>();
+        for (int i = 0; i < grid.length; i++) {
+            int mask = 0;
+            for (int j = 0; j < grid[i].length; j++)
+                mask |= grid[i][j] << j;
+            idx.put(mask, i);
+        }
+        if (idx.containsKey(0)) {
+            return Arrays.asList(idx.get(0));
+        }
+        for (Map.Entry<Integer, Integer> e1 : idx.entrySet()) {
+            for (Map.Entry<Integer, Integer> e2 : idx.entrySet()) {
+                if ((e1.getKey() & e2.getKey()) == 0) {
+                    int i = e1.getValue(), j = e2.getValue();
+                    return i < j ? Arrays.asList(i, j) : Arrays.asList(j, i);
+                }
+            }
+        }
+        return new ArrayList<>();
+    }
+}