weekly contest 341

Author: ZLBer

README.md

@@ -6,6 +6,8 @@ leetcode url: <https://leetcode.cn/u/cctest/>
 
 
 
+* ☀️ [weekly contest 341](src/main/java/weekly/wk341.java)     模拟 | 美剧 | 贪心 | 树形dp
+* ☀️ [weekly contest 340](src/main/java/weekly/wk340.java)     模拟 | 哈希 | 贪心 | bfs+优化
 * ☀️ [weekly contest 339](src/main/java/weekly/wk339.java)     模拟 | 哈希 | 贪心 | 平衡树
 * ☀️ [weekly contest 338](src/main/java/weekly/wk338.java)     贪心 | 谈心 | 前缀和+二分 | 拓扑排序
 * ☀️ [weekly contest 337](src/main/java/weekly/wk337.java)     模拟 | 模拟 | 回溯 | 同余分组
@@ -54,6 +56,8 @@ 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 102](src/main/java/weekly/wkb102.java)   模拟 | 前缀和 | bfs+dfs | Dijkstra
 * 🐸 [biweekly contest 101](src/main/java/weekly/wkb101.java)   哈希 | 滑动窗口 | 并查集 | BFS
 * 🐸 [biweekly contest 100](src/main/java/weekly/wkb100.java)   四维 | 贪心 | 堆 | 二分
 * 🐸 [biweekly contest 99](src/main/java/weekly/wkb99.java)   贪心 | 递推 | 区间合并 | 换根DP

src/main/java/weekly/wk340.java

@@ -0,0 +1,187 @@
+package weekly;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+public class wk340 {
+
+    public static boolean isPrime(int n) {
+        if (n == 0 || n == 1) {
+            return false;
+        }
+        for (int i = 2; i <= (int) Math.sqrt(n); i++) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //求质数
+    public int diagonalPrime(int[][] nums) {
+        int ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (isPrime(nums[i][i])) {
+                ans = Math.max(nums[i][i], ans);
+            }
+            if (isPrime(nums[i][nums.length - i - 1])) {
+                ans = Math.max(nums[i][nums.length - i - 1], ans);
+            }
+        }
+        return ans;
+    }
+
+
+    // 哈希分组+计算增量或前缀和
+    public long[] distance(int[] nums) {
+        long[] arr = new long[nums.length];
+        Map<Integer, List<Integer>> map = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            if (!map.containsKey(nums[i])) map.put(nums[i], new ArrayList<>());
+            map.get(nums[i]).add(i);
+        }
+        for (List<Integer> list : map.values()) {
+            long sum = 0;
+            for (int i = 1; i < list.size(); i++) {
+                sum += list.get(i) - list.get(0);
+            }
+
+            //最左侧直接求差值和
+            arr[list.get(0)] = sum;
+
+            for (int i = 1; i < list.size(); i++) {
+                long dis = list.get(i) - list.get(i - 1);
+                //增加了i个dis，减少了(list.size-i)个ids
+                sum += (i - (list.size() - i)) * dis;
+                arr[list.get(i)] = sum;
+            }
+
+        }
+        return arr;
+    }
+
+
+ /*  static public int minimizeMax(int[] nums, int p) {
+        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> a[0] - b[0]);
+        Arrays.sort(nums);
+        for (int i = 1; i < nums.length; i++) {
+            priorityQueue.add(new int[]{nums[i] - nums[i - 1], i - 1, i});
+        }
+        Set<Integer> set = new HashSet<>();
+        int ans=0;
+        while (p > 0) {
+            int[] cur = priorityQueue.poll();
+            if (!set.contains(cur[1]) && !set.contains(cur[2])) {
+                set.add(cur[1]);
+                set.add(cur[2]);
+                ans=Math.max(cur[0],ans);
+                int left=cur[1]-1;
+                int right=cur[2]+1;
+                if(left>=0&&right<nums.length){
+                    priorityQueue.add(new int[]{nums[right]-nums[left],left,right});
+                }
+                p--;
+            }
+        }
+        return ans;
+    }*/
+
+
+    //最大化最小  考虑二分
+    static public int minimizeMax(int[] nums, int p) {
+        Arrays.sort(nums);
+        int left = 0, right = nums[nums.length - 1] - nums[0];
+
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (check(nums, mid, p)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    static boolean check(int[] nums, int mid, int p) {
+        Deque<Integer> deque = new ArrayDeque<>();
+        int ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (!deque.isEmpty()) {
+                if (nums[i] - deque.peekLast() <= mid) {
+                    ans++;
+                    deque.pollLast();
+                } else {
+                    deque.addLast(nums[i]);
+                }
+            } else {
+                deque.addLast(nums[i]);
+            }
+        }
+        return ans >= p;
+    }
+
+
+    //记录每次每行每列到达的最大位置
+    public int minimumVisitedCells(int[][] grid) {
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+        int m = grid.length;
+        int n = grid[0].length;
+        int[] maxBelow = new int[n];
+        int[] maxRight = new int[m];
+
+        Set<Integer> set = new HashSet<>();
+        int step = 1;
+        set.add(0);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] cur = queue.poll();
+                if (cur[0] == m - 1 && cur[1] == n - 1) {
+                    return step;
+                }
+                int k = grid[cur[0]][cur[1]];
+
+                int belowM = Math.min(m - 1, cur[0] + k);
+                int rightM = Math.min(n - 1, cur[1] + k);
+
+
+                //取最大值，因为可能到不了cur[0]这个位置
+                int begin=Math.max(maxBelow[cur[1]],cur[0]);
+                for (int i = begin; i <= belowM; i++) {
+                    int nx = i, ny = cur[1];
+                    if(set.contains(nx * n + ny)) continue;
+                    set.add(nx * n + ny);
+                    queue.add(new int[]{nx, ny});
+                }
+                //取最大值，因为可能到不了cur[1]这个位置
+                begin=Math.max(maxRight[cur[0]],cur[1]);
+                for (int i =  begin; i <= rightM; i++) {
+                    int nx = cur[0], ny = i;
+                    if(set.contains(nx * n + ny)) continue;
+                    set.add(nx * n + ny);
+                    queue.add(new int[]{nx, ny});
+                }
+                maxBelow[cur[1]]=Math.max(belowM,maxBelow[cur[1]]);
+                maxRight[cur[0]]=Math.max(rightM,maxRight[cur[0]]);
+            }
+            step++;
+        }
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        minimizeMax(new int[]{2, 4, 1, 2}, 1);
+    }
+}

src/main/java/weekly/wk341.java

@@ -0,0 +1,148 @@
+package weekly;
+
+import sun.security.krb5.internal.APRep;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+public class wk341 {
+    //模拟
+    public int[] rowAndMaximumOnes(int[][] mat) {
+        int ans = 0;
+        int count = 0;
+        for (int i = 0; i < mat.length; i++) {
+            int c = 0;
+            for (int j = 0; j < mat[0].length; j++) {
+                if (mat[i][j] == 1) {
+                    c++;
+                }
+            }
+            if (c > count) {
+                count = c;
+                ans = i;
+            }
+        }
+        return new int[]{ans, count};
+    }
+
+
+    //枚举
+    public int maxDivScore(int[] nums, int[] divisors) {
+        int[] score = new int[divisors.length];
+        for (int i = 0; i < divisors.length; i++) {
+            int count = 0;
+            for (int j = 0; j < nums.length; j++) {
+                if (nums[j] % divisors[i] == 0) {
+                    count++;
+                }
+            }
+            score[i] = count;
+        }
+
+        int max = 0;
+        int ans = Integer.MAX_VALUE;
+        for (int i = 0; i < score.length; i++) {
+            if (score[i] > max) {
+                ans = divisors[i];
+                max = score[i];
+            } else if (score[i] == max && divisors[i] < ans) {
+                ans = divisors[i];
+            }
+        }
+        return ans;
+    }
+
+
+    //贪心，尽量用之前没有用完的字母
+    static public int addMinimum(String word) {
+        char pre = 'c';
+        int ans = 0;
+
+        for (int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+            //前面结束
+            if (pre == 'c') {
+                ans += c - 'a';
+                pre = c;
+            } else {
+                if (c > pre) {
+                    ans += c - pre - 1;
+                    pre = c;
+                } else {
+                    //表示前面的需要结束，重新开始
+                    ans += 'c' - pre;
+                    pre = 'c';
+                    i--;
+                }
+            }
+        }
+        ans += 'c' - pre;
+        return ans;
+    }
+
+    //转换成count数组然后树形dp
+    public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] edge : edges) {
+            if (!map.containsKey(edge[0])) map.put(edge[0], new ArrayList<>());
+            if (!map.containsKey(edge[1])) map.put(edge[1], new ArrayList<>());
+            map.get(edge[0]).add(edge[1]);
+            map.get(edge[1]).add(edge[0]);
+        }
+        int[] count = new int[n];
+
+        for (int[] trip : trips) {
+            dfs(map, count, trip[0], trip[1], -1);
+        }
+
+        int[] ans = dfs2(map, count, price, 0, -1);
+        return Math.min(ans[0], ans[1]);
+    }
+
+    boolean dfs(Map<Integer, List<Integer>> map, int[] count, int cur, int target, int parent) {
+        if (cur == target) {
+            count[cur]++;
+            return true;
+        }
+
+        for (Integer next : map.getOrDefault(cur, new ArrayList<>())) {
+            if (next == parent) continue;
+            //是路径上的点
+            if (dfs(map, count, next, target, cur)) {
+                count[cur]++;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    int[] dfs2(Map<Integer, List<Integer>> map, int[] count, int[] price, int cur, int parent) {
+
+        int[] ans = new int[]{price[cur] * count[cur], price[cur] * count[cur]/2};
+
+        int childMaxSum = 0;
+        int childNoSum = 0;
+        for (Integer next : map.getOrDefault(cur, new ArrayList<>())) {
+            if (next == parent) continue;
+            int[] child = dfs2(map, count, price, next, cur);
+            childMaxSum += Math.min(child[0], child[1]);
+            childNoSum += child[0];
+        }
+        ans[0] += childMaxSum;
+        ans[1] +=childNoSum;
+        return ans;
+    }
+
+
+    public static void main(String[] args) {
+        wk341 w = new wk341();
+        w.minimumTotalPrice(4, new int[][]{{0, 1}, {1, 2}, {1, 3}}, new int[]{2, 2, 10, 6}, new int[][]{{0, 3}, {2, 1}, {2, 3}});
+    }
+}