2025/01/30 22:23 打卡

JavaCode/random_records/N2401_N2600/N2555_maximize_win_from_two_segments.java

@@ -0,0 +1,77 @@
+package JavaCode.random_records.N2401_N2600;
+
+import utils.CheckUtil;
+import utils.Parse;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * @author mikusugar
+ * @version 1.0, 2024/9/11 17:07
+ * @description maximize-win-from-two-segments
+ */
+public class N2555_maximize_win_from_two_segments {
+    public static void main(String[] args) {
+        final N2555_maximize_win_from_two_segments solve = new N2555_maximize_win_from_two_segments();
+        CheckUtil.check(7, solve.maximizeWin(Parse.toIntArr("[1,1,2,2,3,3,5]"), 2));
+    }
+
+    public int maximizeWin(int[] prizePositions, int k) {
+        int[] add = new int[prizePositions[prizePositions.length - 1]+1];
+        for (int i = 0; i < prizePositions.length; i++) {
+            add[prizePositions[i]]++;
+        }
+
+        int[] sum = new int[add.length + 1];
+        for (int i = 0; i < add.length; i++) {
+            sum[i + 1] = sum[i] + add[i];
+        }
+        int[][] arr = new int[add.length][2];
+        for (int i = k; i < add.length; i++) {
+            arr[i][0] = i;
+            arr[i][1] = sum[i + 1] - sum[i - k];
+        }
+        Arrays.sort(arr, Comparator.comparingInt(o -> o[1]));
+        int res = 0;
+        boolean[] book = new boolean[add.length];
+        for (int i = arr[arr.length - 1][0]; i >= arr[arr.length - 1][0] - k; i--) {
+            book[i] = true;
+            res += add[i];
+        }
+        for (int i = arr[arr.length - 2][0]; i >= arr[arr.length - 1][0] - k; i--) {
+            if (book[i]) continue;
+            res += add[i];
+        }
+        return res;
+    }
+}
+/*
+在 X轴 上有一些奖品。给你一个整数数组 prizePositions ，它按照 非递减 顺序排列，其中 prizePositions[i] 是第 i 件奖品的位置。数轴上一个位置可能会有多件奖品。再给你一个整数 k 。
+
+你可以同时选择两个端点为整数的线段。每个线段的长度都必须是 k 。你可以获得位置在任一线段上的所有奖品（包括线段的两个端点）。注意，两个线段可能会有相交。
+
+比方说 k = 2 ，你可以选择线段 [1, 3] 和 [2, 4] ，你可以获得满足 1 <= prizePositions[i] <= 3 或者 2 <= prizePositions[i] <= 4 的所有奖品 i 。
+请你返回在选择两个最优线段的前提下，可以获得的 最多 奖品数目。
+
+
+
+示例 1：
+
+输入：prizePositions = [1,1,2,2,3,3,5], k = 2
+输出：7
+解释：这个例子中，你可以选择线段 [1, 3] 和 [3, 5] ，获得 7 个奖品。
+示例 2：
+
+输入：prizePositions = [1,2,3,4], k = 0
+输出：2
+解释：这个例子中，一个选择是选择线段 [3, 3] 和 [4, 4] ，获得 2 个奖品。
+
+
+提示：
+
+1 <= prizePositions.length <= 105
+1 <= prizePositions[i] <= 109
+0 <= k <= 109
+prizePositions 有序非递减。
+ */

JavaCode/random_records/N3001_N3400/N3067_count_pairs_of_connectable_servers_in_a_weighted_tree_network.java

@@ -0,0 +1,90 @@
+package JavaCode.random_records.N3001_N3400;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author mikusugar
+ * @version 1.0, 2024/8/13 17:03
+ * @description N3067_count_pairs_of_connectable_servers_in_a_weighted_tree_network
+ */
+public class N3067_count_pairs_of_connectable_servers_in_a_weighted_tree_network {
+    private int n;
+    private List<int[]>[] graph;
+    private int signalSpeed;
+
+    public int[] countPairsOfConnectableServers(int[][] edges, int signalSpeed) {
+        this.n = edges.length + 1;
+        this.graph = new ArrayList[n];
+        this.signalSpeed = signalSpeed;
+
+        for (int i = 0; i < n; i++) {
+            graph[i] = new ArrayList<>();
+        }
+        for (int[] edge : edges) {
+            graph[edge[0]].add(new int[]{edge[1], edge[2]});
+            graph[edge[1]].add(new int[]{edge[0], edge[2]});
+        }
+        int[] result = new int[n];
+        for (int i = 0; i < n; i++) {
+            result[i] = handle(i);
+        }
+
+        return result;
+    }
+
+    private int handle(int i) {
+        List<Integer> dist = new ArrayList<>();
+        boolean[] visited = new boolean[n];
+        return 0;
+    }
+
+}
+/*
+3067. 在带权树网络中统计可连接服务器对数目
+中等
+相关标签
+相关企业
+提示
+给你一棵无根带权树，树中总共有 n 个节点，分别表示 n 个服务器，服务器从 0 到 n - 1 编号。同时给你一个数组 edges ，其中 edges[i] = [ai, bi, weighti] 表示节点 ai 和 bi 之间有一条双向边，边的权值为 weighti 。再给你一个整数 signalSpeed 。
+
+如果两台服务器 a 和 b 是通过服务器 c 可连接的，则：
+
+a < b ，a != c 且 b != c 。
+从 c 到 a 的距离是可以被 signalSpeed 整除的。
+从 c 到 b 的距离是可以被 signalSpeed 整除的。
+从 c 到 b 的路径与从 c 到 a 的路径没有任何公共边。
+请你返回一个长度为 n 的整数数组 count ，其中 count[i] 表示通过服务器 i 可连接 的服务器对的 数目 。
+
+
+
+示例 1：
+
+
+
+输入：edges = [[0,1,1],[1,2,5],[2,3,13],[3,4,9],[4,5,2]], signalSpeed = 1
+输出：[0,4,6,6,4,0]
+解释：由于 signalSpeed 等于 1 ，count[c] 等于所有从 c 开始且没有公共边的路径对数目。
+在输入图中，count[c] 等于服务器 c 左边服务器数目乘以右边服务器数目。
+示例 2：
+
+
+
+输入：edges = [[0,6,3],[6,5,3],[0,3,1],[3,2,7],[3,1,6],[3,4,2]], signalSpeed = 3
+输出：[2,0,0,0,0,0,2]
+解释：通过服务器 0 ，有 2 个可连接服务器对(4, 5) 和 (4, 6) 。
+通过服务器 6 ，有 2 个可连接服务器对 (4, 5) 和 (0, 5) 。
+所有服务器对都必须通过服务器 0 或 6 才可连接，所以其他服务器对应的可连接服务器对数目都为 0 。
+
+
+提示：
+
+2 <= n <= 1000
+edges.length == n - 1
+edges[i].length == 3
+0 <= ai, bi < n
+edges[i] = [ai, bi, weighti]
+1 <= weighti <= 106
+1 <= signalSpeed <= 106
+输入保证 edges 构成一棵合法的树。
+ */

JavaCode/random_records/N3001_N3400/N3151_special_array_i.java

@@ -0,0 +1,61 @@
+package JavaCode.random_records.N3001_N3400;
+
+/**
+ * @author mikusugar
+ * @version 1.0, 2024/8/13 16:54
+ * @description N3151_special_array_i
+ */
+public class N3151_special_array_i {
+    public boolean isArraySpecial(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i - 1] % 2 == nums[i] % 2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+/*
+如果数组的每一对相邻元素都是两个奇偶性不同的数字，则该数组被认为是一个 特殊数组 。
+
+Aging 有一个整数数组 nums。如果 nums 是一个 特殊数组 ，返回 true，否则返回 false。
+
+
+
+示例 1：
+
+输入：nums = [1]
+
+输出：true
+
+解释：
+
+只有一个元素，所以答案为 true。
+
+示例 2：
+
+输入：nums = [2,1,4]
+
+输出：true
+
+解释：
+
+只有两对相邻元素： (2,1) 和 (1,4)，它们都包含了奇偶性不同的数字，因此答案为 true。
+
+示例 3：
+
+输入：nums = [4,3,1,6]
+
+输出：false
+
+解释：
+
+nums[1] 和 nums[2] 都是奇数。因此答案为 false。
+
+
+
+提示：
+
+1 <= nums.length <= 100
+1 <= nums[i] <= 100
+ */

rust/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

rust/src/main.rs

@@ -0,0 +1,7 @@
+mod n350_intersection_of_two_arrays_ii;
+
+fn main() {
+    // let res = 
+    //     n350_intersection_of_two_arrays_ii::intersect(vec![4, 9, 5], vec![9, 4, 9, 8, 4]);
+    // println!("res: {:?}", res);
+}

rust/src/n350_intersection_of_two_arrays_ii.rs

@@ -0,0 +1,51 @@
+use std::cmp;
+use std::collections::HashMap;
+
+pub fn intersect(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+    let mut map1 = HashMap::new();
+    for num in nums1 {
+        *map1.entry(num).or_insert(0) += 1;
+    }
+    let mut map2 = HashMap::new();
+    for num in nums2 {
+        *map2.entry(num).or_insert(0) += 1;
+    }
+    let mut res = Vec::new();
+    for (num, count) in map1 {
+        if let Some(val) = map2.get(&num) {
+            let cnt = cmp::min(count, *val);
+            for _ in 0..cnt {
+                res.push(num);
+            }
+        }
+    }
+    res
+}
+/*
+给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
+
+
+
+示例 1：
+
+输入：nums1 = [1,2,2,1], nums2 = [2,2]
+输出：[2,2]
+示例 2:
+
+输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+输出：[4,9]
+
+
+提示：
+
+1 <= nums1.length, nums2.length <= 1000
+0 <= nums1[i], nums2[i] <= 1000
+
+
+进阶：
+
+如果给定的数组已经排好序呢？你将如何优化你的算法？
+如果 nums1 的大小比 nums2 小，哪种方法更优？
+如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
+https://leetcode.cn/problems/intersection-of-two-arrays-ii/description/?envType=daily-question&envId=2025-01-30
+ */