weekly contest 365

Author: ZLBer

README.md

@@ -4,6 +4,9 @@ Record leetcode contest and ideas every week, and encourage yourself to think mo
 
 leetcode url: <https://leetcode.cn/u/cctest/>
 
+
+
+* 🐼 [weekly contest 365](src/main/java/weekly/wk365.java)     枚举 | 枚举 | 滑动窗口 | 内向基环树
 * 🐼 [weekly contest 364](src/main/java/weekly/wk364.java)     贪心 | 单调栈 | 单调栈 | dfs
 * 🐼 [weekly contest 363](src/main/java/weekly/wk363.java)     暴力 | 遍历 | 二分 | 质数分解
 * 🐼 [weekly contest 362](src/main/java/weekly/wk362.java)     差分数组 | 贪心 | 全排列 | 
@@ -74,6 +77,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 114](src/main/java/weekly/wkb114.java)   哈希 | 贪心 | &运算 | 贪心+dfs
 * 🐸 [biweekly contest 113](src/main/java/weekly/wkb113.java)   遍历 | 贪心 | 哈希 | 换根dp
 * 🐸 [biweekly contest 112](src/main/java/weekly/wkb112.java)   哈希 | 哈希 | 哈希+滑窗 | 组合数
 * 🐸 [biweekly contest 111](src/main/java/weekly/wkb111.java)   遍历 | 贪心+双指针 | 前缀和、dp | 数位dp

src/main/java/weekly/wk365.java

@@ -0,0 +1,121 @@
+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 wk365 {
+ /*   public long maximumTripletValue(int[] nums) {
+        long max = 0;
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                for (int k = j + 1; k < nums.length; k++) {
+                    max = Math.max(max, ((long) nums[i] - nums[j]) * nums[k]);
+                }
+            }
+        }
+        return max;
+    }*/
+
+
+    //枚举
+    public long maximumTripletValue(int[] nums) {
+        long max = 0;
+        long sub = 0;
+        long ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            ans = Math.max(ans, sub * nums[i]);
+
+            sub = Math.max(sub, max - nums[i]);
+            max = Math.max(max, nums[i]);
+        }
+        return ans;
+    }
+
+
+    //滑动窗口+分类
+    public int minSizeSubarray(int[] nums, int target) {
+        long total = 0;
+        for (int x : nums) total += x;
+        int n = nums.length;
+        int ans = Integer.MAX_VALUE;
+        int left = 0;
+        long sum = 0;
+        for (int right = 0; right < n * 2; right++) {
+            sum += nums[right % n];
+            while (sum > target % total) {
+                sum -= nums[left++ % n];
+            }
+            if (sum == target % total) {
+                ans = Math.min(ans, right - left + 1);
+            }
+        }
+        return ans == Integer.MAX_VALUE ? -1 : ans + (int) (target / total) * n;
+    }
+
+
+    //内向基环树
+   static public int[] countVisitedNodes(List<Integer> edges) {
+
+
+        int[] ans = new int[edges.size()];
+        int[] in = new int[edges.size()];
+        for (Integer edge : edges) {
+            in[edge]++;
+        }
+
+        for (int i = 0; i < edges.size(); i++) {
+
+            int cur = i;
+            if (ans[cur] != 0) continue;
+            int time = 0;
+            Map<Integer, Integer> set = new HashMap<>();
+            List<Integer> list = new ArrayList<>();
+            set.put(cur, time);
+            list.add(cur);
+
+            while (true) {
+                time++;
+                cur = edges.get(cur);
+                //之前计算过了
+                if (ans[cur] != 0) {
+                    for (int j = 0; j < list.size(); j++) {
+                        ans[list.get(j)] = ans[cur] + list.size() - j;
+                    }
+                    break;
+                }
+                //存在圈
+                if (set.containsKey(cur)) {
+                    int circleIn = set.get(cur);
+                    int circle = time - circleIn;
+                    for (int j = 0; j < list.size(); j++) {
+                        //在圈之前
+                        if (j < circleIn) {
+                            ans[list.get(j)] = circle + circleIn - j;
+                            //在圈里
+                        } else {
+                            ans[list.get(j)] = circle;
+                        }
+                    }
+                    break;
+                }
+                set.put(cur, time);
+                list.add(cur);
+
+            }
+
+
+        }
+
+        return ans;
+    }
+
+
+    public static void main(String[] args) {
+       countVisitedNodes(Arrays.asList(1,2,0,0));
+    }
+}

src/main/java/weekly/wkb114.java

@@ -0,0 +1,115 @@
+package weekly;
+
+import java.net.Inet4Address;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class wkb114 {
+
+
+    // hash
+    public int minOperations(List<Integer> nums, int k) {
+        Set<Integer> set = new HashSet<>();
+        for (int i = 1; i <= k; i++) {
+            set.add(i);
+        }
+        int ans = 0;
+        for (int size = nums.size() - 1; size >= 0; size--) {
+            set.remove(nums.get(size));
+            ans++;
+            if (set.size() == 0) return ans;
+        }
+        return ans;
+    }
+
+    //贪心
+    public int minOperations(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
+        }
+        int ans = 0;
+        for (Integer value : map.values()) {
+            if (value == 1) {
+                return -1;
+            }
+            if (value % 3 == 0) {
+                ans += value / 3;
+            } else if (value % 3 == 1) {
+                ans += (value - 1) / 3 + 1;
+            } else {
+                ans += value / 3 + 1;
+            }
+        }
+        return ans;
+    }
+
+
+    // &运算性质
+    static public int maxSubarrays(int[] nums) {
+        int sum = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            sum &= nums[i];
+        }
+        int ans = 0;
+
+        //&和为0的时候特殊计算
+        if (sum == 0) {
+            int pre = nums[0];
+            for (int i = 1; i < nums.length; i++) {
+                if (pre == sum) {
+                    ans++;
+                    pre = nums[i];
+                } else {
+                    pre &= nums[i];
+                }
+            }
+            if (pre == sum) {
+                ans++;
+            }
+        } else {
+            ans = 1;
+        }
+
+
+        return ans;
+    }
+
+
+    //贪心
+    public int maxKDivisibleComponents(int n, int[][] edges, int[] values, int k) {
+        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]);
+        }
+        return (int) dfs(-1, 0, map, values, k)[0];
+    }
+
+    long[] dfs(int parent, int cur, Map<Integer, List<Integer>> map, int[] values, int k) {
+
+        long val = values[cur];
+        long ans = 0;
+        for (Integer child : map.getOrDefault(cur, new ArrayList<>())) {
+            if (child == parent) continue;
+            long[] ints = dfs(cur, child, map, values, k);
+            ans += ints[0];
+            val += ints[1];
+        }
+        if (val % k == 0) {
+            ans += 1;
+        }
+
+        return new long[]{ans, val};
+    }
+}