weekly contest 319

Author: ZLBer

README.md

@@ -4,6 +4,8 @@ Record leetcode contest and ideas every week, and encourage yourself to think mo
 
 leetcode url: <https://leetcode.cn/u/cctest/>
 
+
+* ☀️ [weekly contest 319](src/main/java/weekly/wk319.java)     模拟 | 暴力 | 置换环 | DP
 * ☀️ [weekly contest 318](src/main/java/weekly/wk318.java)     模拟 | 滑动窗口 | 双指针 | DP
 * ☀️ [weekly contest 317](src/main/java/weekly/wk317.java)     数组 | hash | 贪心+模拟 | 树形DP
 * ☀️ [weekly contest 316](src/main/java/weekly/wk316.java)     模拟 | gcd | 前缀和 | 分情况
@@ -35,6 +37,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 91](src/main/java/weekly/wkb91.java)   排序 | DO | DFS | 找规律
 * 🐸 [biweekly contest 90](src/main/java/weekly/wkb90.java)   hash | 遍历 | 分组求余 | 单调栈+优先队列
 * 🐸 [biweekly contest 89](src/main/java/weekly/wkb89.java)   判断 | 前缀和 | 贪心、二分 | 枚举+DFS
 * 🐘 [biweekly contest 88](src/main/java/weekly/wkb88.java)   模拟 | 指针 | 脑筋急转弯 | 线段树

src/main/java/weekly/wk319.java

@@ -0,0 +1,192 @@
+package weekly;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+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 wk319 {
+
+    //ranking: 628 / 6175
+
+    //模拟
+    public double[] convertTemperature(double celsius) {
+        return new double[]{celsius + 273.15, celsius * 1.80 + 32};
+    }
+
+
+    //暴力做的
+    public int subarrayLCM(int[] nums, int k) {
+
+        int res = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int s = nums[i];
+            for (int j = i; j < nums.length; j++) {
+                //两数乘积＝两数的最大公因数×两数的最小公倍数
+                s = (int) (s / gcd(nums[j], s) * nums[j]);
+                if (s == k) {
+                    res++;
+                }
+                if (s > k) break;
+            }
+            System.out.println(res);
+        }
+        return res;
+    }
+
+    long gcd(long a, long b) {
+        while (b != 0) {
+            long temp = a % b;
+            a = b;
+            b = temp;
+        }
+        return a;
+    }
+
+//    public static int getCM(int m, int n) {
+//        for (int i = (m > n ? m : n); i <= m * n; i++) {
+//            if (i % n == 0 && i % m == 0) {
+//                return i;
+//            }
+//        }
+//        return -1;
+//    }
+
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode() {
+        }
+
+        TreeNode(int val) {
+            this.val = val;
+        }
+
+        TreeNode(int val, TreeNode left, TreeNode right) {
+            this.val = val;
+            this.left = left;
+            this.right = right;
+        }
+    }
+
+
+    //层序遍历，然后求每层的最小交换此次数，问题转换了-置换环
+    public int minimumOperations(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        int res = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            List<Integer> list = new ArrayList<>(size);
+            while (size-- > 0) {
+                TreeNode node = queue.poll();
+                list.add(node.val);
+                if (node.left != null) queue.add(node.left);
+                if (node.right != null) queue.add(node.right);
+            }
+            int ans = minSwaps(list);
+            res += ans;
+        }
+        return res;
+    }
+
+    public static int minSwaps(List<Integer> list) {
+        int n = list.size();
+
+        ArrayList<int[]> arrpos = new ArrayList<>();
+        for (int i = 0; i < n; i++)
+            arrpos.add(new int[]{list.get(i), i});
+
+        arrpos.sort(new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if (o1[0] < o2[0])
+                    return -1;
+                else if (o1[0] == o2[0])
+                    return 0;
+                else
+                    return 1;
+            }
+        });
+        boolean[] vis = new boolean[n];
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+            if (vis[i] || arrpos.get(i)[1] == i)
+                continue;
+            int cycle_size = 0;
+            int j = i;
+            while (!vis[j]) {
+                vis[j] = true;
+                j = arrpos.get(j)[1];
+                cycle_size++;
+            }
+            if (cycle_size > 0) {
+                ans += (cycle_size - 1);
+            }
+        }
+        return ans;
+    }
+
+    //dp
+    static public int maxPalindromes(String s, int k) {
+        int[] dp = new int[s.length() + 1];
+        boolean[][] can = new boolean[s.length()][s.length()];
+        for (int i = 0; i < can.length; i++) {
+            can[i][i] = true;
+        }
+        //求所有的回文串，这里也可以中心扩展法
+        for (int len = 2; len <= s.length(); len++) {
+            for (int i = 0; i + len <= s.length(); i++) {
+                if (s.charAt(i) == s.charAt(i + len - 1)) {
+                    if (len == 2) {
+                        can[i][i + len - 1] = true;
+                    } else {
+                        can[i][i + len - 1] |= can[i + 1][i + len - 2];
+                    }
+                }
+            }
+        }
+
+        if (can[0][k - 1]) {
+            dp[k] = 1;
+        }
+
+        //dp[i]表示i结尾的满足长度为k的回文序列的个数
+        //从k长度开始找
+        for (int i = k; i < s.length(); i++) {
+            dp[i + 1] = dp[i];
+            for (int begin = i - k + 1; begin >= 0; begin--) {
+                if (can[begin][i]) {
+                    dp[i + 1] = Math.max(dp[i + 1], dp[begin] + 1);
+                }
+            }
+        }
+        return dp[dp.length - 1];
+    }
+
+    //检查是不是回文串
+    static boolean check(String s, int begin, int end) {
+        while (begin < end) {
+            if (s.charAt(begin) != s.charAt(end)) {
+                return false;
+            }
+            begin++;
+            end--;
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        maxPalindromes("fttfjofpnpfydwdwdnns", 2);
+    }
+
+}

src/main/java/weekly/wkb91.java

@@ -0,0 +1,158 @@
+package weekly;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class wkb91 {
+    //ranking: 400 / 3535
+    //排序+hash
+    public int distinctAverages(int[] nums) {
+        Arrays.sort(nums);
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < nums.length / 2; i++) {
+            set.add(nums[i] + nums[nums.length - 1 - i]);
+        }
+        return set.size();
+    }
+
+    // dp
+    public int countGoodStrings(int low, int high, int zero, int one) {
+        long[] dp = new long[high + 1];
+        int mod = (int) 1e9 + 7;
+        dp[0] = 1;
+        for (int i = 0; i < dp.length; i++) {
+            if (i - zero > 0) dp[i] += dp[i - zero];
+            if (i - one > 0) dp[i] += dp[i - one];
+            dp[i] %= mod;
+        }
+        long res = 0;
+        for (int i = low; i <= high; i++) {
+            res += dp[i];
+            res %= mod;
+        }
+        return (int) res;
+    }
+
+
+    //两次dfs
+    public int mostProfitablePath(int[][] edges, int bob, int[] amount) {
+        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]);
+        }
+        arrivedTime = new HashMap<>();
+        helpBob(0, -1, bob, 0, map);
+
+        return helpAlice(0, -1, 0, map, amount);
+    }
+
+    int bobStep;
+    Map<Integer, Integer> arrivedTime;
+
+     //bob的路线是固定的，计算bob打到每个节点的步数
+    boolean helpBob(int cur, int pre, int bob, int step, Map<Integer, List<Integer>> map) {
+        if (cur == bob) {
+            arrivedTime.put(cur, step);
+            bobStep = step;
+            return true;
+        }
+
+        boolean flag = false;
+        for (Integer next : map.getOrDefault(cur, new ArrayList<>())) {
+            if (next == pre) continue;
+            flag |= helpBob(next, cur, bob, step + 1, map);
+        }
+        if (flag) {
+            arrivedTime.put(cur, step);
+        }
+        return flag;
+    }
+
+    //求alice达到每个叶子结点的分数，求最大
+    int helpAlice(int cur, int pre, int step, Map<Integer, List<Integer>> map, int[] amount) {
+        int score = 0;
+        if (arrivedTime.containsKey(cur)) {
+            int time = bobStep - arrivedTime.get(cur);
+            //比bob先打到
+            if (time > step) {
+                score += amount[cur];
+                //一起到达
+            } else if (time == step) {
+                score += amount[cur] / 2;
+            }
+            //bob没有经过
+        } else {
+            score += amount[cur];
+        }
+
+        int max = Integer.MIN_VALUE;
+        for (Integer next : map.getOrDefault(cur, new ArrayList<>())) {
+            if (next == pre) continue;
+            max = Math.max(max, helpAlice(next, cur, step + 1, map, amount));
+        }
+        //这里表示没有路了
+        if (max == Integer.MIN_VALUE) {
+            max = 0;
+        }
+        return score + max;
+    }
+
+
+    //写的好麻烦，本质是找规律
+    public String[] splitMessage(String message, int limit) {
+        int length = message.length();
+        int number = check(length, limit);
+        if (number == -1) {
+            return new String[]{};
+        }
+        int l = (number + "").length();
+        String[] res = new String[number];
+        int begin = 0;
+        for (int i = 1; i <= number; i++) {
+            int r = (i + "").length();
+            int end = begin + (limit - 3 - r - l);
+            res[i - 1] = message.substring(begin, Math.min(message.length(), end)) + "<" + i + "/" + number + ">";
+            begin = end;
+        }
+        return res;
+    }
+
+    //计算要分成多少组
+    int check(int len, int limit) {
+        for (int i = 1; i < arr.length + 1; i++) {
+            long sum = 0;
+            for (int j = 0; j < i; j++) {
+                sum += (long) arr[j] * (limit - i - j - 1 - 3);
+            }
+            if (sum >= len) {
+                int count=0;
+                for (int j = 0; j < i - 1; j++) {
+                    count+=arr[j];
+                    len -= arr[j] * (limit - i - j - 1 - 3);
+                }
+                int l = len / (limit - i  - i - 3);
+                if (l * (limit - i - i - 3) != len) {
+                    l++;
+                }
+                return count + l;
+            }
+        }
+        return -1;
+    }
+
+    int[] arr = new int[]{9, 90, 900, 9000, 90000, 900000};
+
+//    public static void main(String[] args) {
+//        wk319 w = new wk319();
+//        w.check(10000, 12);
+//        w.splitMessage("this is really a very awesome message", 9);
+//    }
+}