2024/07/22 16:54 打卡

JavaCode/random_records/N2201_N2400/N2369_check_if_there_is_a_valid_partition_for_the_array.java

@@ -0,0 +1,78 @@
+package JavaCode.random_records.N2201_N2400;
+
+import utils.CheckUtil;
+import utils.Parse;
+
+/**
+ * @author mikusugar
+ * @version 1.0, 2024/7/22 下午4:26
+ * @description N2369_check_if_there_is_a_valid_partition_for_the_array
+ */
+public class N2369_check_if_there_is_a_valid_partition_for_the_array {
+    public static void main(String[] args) {
+        CheckUtil.check(new N2369_check_if_there_is_a_valid_partition_for_the_array()
+                .validPartition(Parse.toIntArr("[865579,865579,893593]")), false);
+    }
+
+
+    public boolean validPartition(int[] nums) {
+        boolean[] used = new boolean[nums.length];
+        return dfs(0, nums, used);
+    }
+
+    private boolean dfs(int index, int[] nums, boolean[] used) {
+        if (index == nums.length) return true;
+        if (used[index]) return false;
+        used[index] = true;
+        boolean result = false;
+        if (helpCheck2(nums, index)) {
+            result = dfs(index + 2, nums, used);
+        }
+        if (result) return true;
+        if (helpCheck3(nums, index)) {
+            return dfs(index + 3, nums, used);
+        }
+        return false;
+    }
+
+    private boolean helpCheck2(int[] nums, int index) {
+        if (index > nums.length - 2) return false;
+        return nums[index] == nums[index + 1];
+    }
+
+    private boolean helpCheck3(int[] nums, int index) {
+        if (index > nums.length - 3) return false;
+        return (nums[index] == nums[index + 1] && nums[index] == nums[index + 2]) ||
+                (nums[index] + 1 == nums[index + 1] && nums[index] + 2 == nums[index + 2]);
+    }
+}
+/*
+给你一个下标从 0 开始的整数数组 nums ，你必须将数组划分为一个或多个 连续 子数组。
+
+如果获得的这些子数组中每个都能满足下述条件 之一 ，则可以称其为数组的一种 有效 划分：
+
+子数组 恰 由 2 个相等元素组成，例如，子数组 [2,2] 。
+子数组 恰 由 3 个相等元素组成，例如，子数组 [4,4,4] 。
+子数组 恰 由 3 个连续递增元素组成，并且相邻元素之间的差值为 1 。例如，子数组 [3,4,5] ，但是子数组 [1,3,5] 不符合要求。
+如果数组 至少 存在一种有效划分，返回 true ，否则，返回 false 。
+
+
+
+示例 1：
+
+输入：nums = [4,4,4,5,6]
+输出：true
+解释：数组可以划分成子数组 [4,4] 和 [4,5,6] 。
+这是一种有效划分，所以返回 true 。
+示例 2：
+
+输入：nums = [1,1,1,2]
+输出：false
+解释：该数组不存在有效划分。
+
+
+提示：
+
+2 <= nums.length <= 10^5
+1 <= nums[i] <= 10^6
+ */

JavaCode/random_records/N2201_N2400/N2385_amount_of_time_for_binary_tree_to_be_infected.java

@@ -0,0 +1,108 @@
+package JavaCode.random_records.N2201_N2400;
+
+import JavaCode.data_structure_binary_tree.TreeNode;
+
+import java.util.*;
+
+
+/**
+ * @author mikusugar
+ * @version 1.0, 2024/4/30 下午5:01
+ * @description N2385_amount_of_time_for_binary_tree_to_be_infected
+ */
+public class N2385_amount_of_time_for_binary_tree_to_be_infected {
+    /**
+     * Definition for a binary tree node.
+     * 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;
+     * }
+     * }
+     */
+
+    private int time;
+
+    private BitSet book;
+
+    public int amountOfTime(TreeNode root, int start) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        convert2Graph(root, graph);
+        this.time = 0;
+        book = new BitSet();
+        dfs(graph, start, 0);
+        return time;
+    }
+
+    private void dfs(Map<Integer, List<Integer>> graph, int cur, int level) {
+        if (this.book.get(cur)) {
+            return;
+        }
+        this.book.set(cur);
+        this.time = Math.max(this.time, level);
+        final List<Integer> next = graph.getOrDefault(cur, Collections.emptyList());
+        next.forEach(n -> dfs(graph, n, level + 1));
+    }
+
+    private void convert2Graph(TreeNode node, Map<Integer, List<Integer>> graph) {
+        if (node == null) return;
+        final List<Integer> next = graph.computeIfAbsent(node.val, k -> new ArrayList<>(3));
+        if (node.left != null) {
+            next.add(node.left.val);
+            graph.computeIfAbsent(node.left.val, k -> new ArrayList<>(3)).add(node.val);
+            convert2Graph(node.left, graph);
+        }
+        if (node.right != null) {
+            next.add(node.right.val);
+            graph.computeIfAbsent(node.right.val, k -> new ArrayList<>(3)).add(node.val);
+            convert2Graph(node.right, graph);
+        }
+    }
+
+
+}
+/*
+给你一棵二叉树的根节点 root ，二叉树中节点的值 互不相同 。另给你一个整数 start 。在第 0 分钟，感染 将会从值为 start 的节点开始爆发。
+
+每分钟，如果节点满足以下全部条件，就会被感染：
+
+节点此前还没有感染。
+节点与一个已感染节点相邻。
+返回感染整棵树需要的分钟数。
+
+
+
+示例 1：
+
+
+输入：root = [1,5,3,null,4,10,6,9,2], start = 3
+输出：4
+解释：节点按以下过程被感染：
+- 第 0 分钟：节点 3
+- 第 1 分钟：节点 1、10、6
+- 第 2 分钟：节点5
+- 第 3 分钟：节点 4
+- 第 4 分钟：节点 9 和 2
+感染整棵树需要 4 分钟，所以返回 4 。
+示例 2：
+
+
+输入：root = [1], start = 1
+输出：0
+解释：第 0 分钟，树中唯一一个节点处于感染状态，返回 0 。
+
+
+提示：
+
+树中节点的数目在范围 [1, 105] 内
+1 <= Node.val <= 105
+每个节点的值 互不相同
+树中必定存在值为 start 的节点
+https://leetcode.cn/problems/amount-of-time-for-binary-tree-to-be-infected
+ */

python3/N2798_number_of_employees_who_met_the_target.py

@@ -0,0 +1,41 @@
+from typing import List
+
+
+class Solution:
+    def numberOfEmployeesWhoMetTarget(self, hours: List[int], target: int) -> int:
+        return sum(1 for hour in hours if hour >= target)
+
+# 公司里共有 n 名员工，按从 0 到 n - 1 编号。每个员工 i 已经在公司工作了 hours[i] 小时。
+#
+# 公司要求每位员工工作 至少 target 小时。
+#
+# 给你一个下标从 0 开始、长度为 n 的非负整数数组 hours 和一个非负整数 target 。
+#
+# 请你用整数表示并返回工作至少 target 小时的员工数。
+#
+#
+#
+# 示例 1：
+#
+# 输入：hours = [0,1,2,3,4], target = 2
+# 输出：3
+# 解释：公司要求每位员工工作至少 2 小时。
+# - 员工 0 工作 0 小时，不满足要求。
+# - 员工 1 工作 1 小时，不满足要求。
+# - 员工 2 工作 2 小时，满足要求。
+# - 员工 3 工作 3 小时，满足要求。
+# - 员工 4 工作 4 小时，满足要求。
+# 共有 3 位满足要求的员工。
+# 示例 2：
+#
+# 输入：hours = [5,1,4,2,2], target = 6
+# 输出：0
+# 解释：公司要求每位员工工作至少 6 小时。
+# 共有 0 位满足要求的员工。
+#
+#
+# 提示：
+#
+# 1 <= n == hours.length <= 50
+# 0 <= hours[i], target <= 105
+# https://leetcode.cn/problems/number-of-employees-who-met-the-target

python3/N6451_find_the_maximum_achievable_number.py

@@ -0,0 +1,40 @@
+class Solution:
+    def theMaximumAchievableX(self, num: int, t: int) -> int:
+        return num + t * 2
+
+
+"""
+给你两个整数 num 和 t 。
+
+如果整数 x 可以在执行下述操作不超过 t 次的情况下变为与 num 相等，则称其为 可达成数字 ：
+
+每次操作将 x 的值增加或减少 1 ，同时可以选择将 num 的值增加或减少 1 。
+返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。
+
+ 
+
+示例 1：
+
+输入：num = 4, t = 1
+输出：6
+解释：最大可达成数字是 x = 6 ，执行下述操作可以使其等于 num ：
+- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。 
+可以证明不存在大于 6 的可达成数字。
+示例 2：
+
+输入：num = 3, t = 2
+输出：7
+解释：最大的可达成数字是 x = 7 ，执行下述操作可以使其等于 num ：
+- x 减少 1 ，同时 num 增加 1 。此时，x = 6 且 num = 4 。 
+- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。 
+可以证明不存在大于 7 的可达成数字。
+ 
+
+提示：
+
+1 <= num, t <= 50
+
+来源：力扣（LeetCode）
+链接：https://leetcode.cn/problems/find-the-maximum-achievable-number
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+"""

python3/N6899_maximum_number_of_jumps_to_reach_the_last_index.py

@@ -0,0 +1,84 @@
+from typing import List
+import sys
+
+
+class Solution:
+
+    def maximumJumps(self, nums: List[int], target: int) -> int:
+        dp = {}
+        res = self.dfs(0, nums, target, dp)
+        if res < 0:
+            res = -1
+        return res
+
+    def dfs(self, cur, nums, target, dp: dict) -> int:
+        if cur in dp:
+            return dp[cur]
+        if cur == len(nums) - 1:
+            return 0
+        res = -2 ** 31
+        for i in range(cur + 1, len(nums)):
+            if abs(nums[i] - nums[cur]) <= target:
+                res = max(res, 1 + self.dfs(i, nums, target, dp))
+        dp[cur] = res
+        return res
+
+
+if __name__ == '__main__':
+    sys.setrecursionlimit(100000)
+    s = Solution()
+    print(s.maximumJumps([1, 3, 6, 4, 1, 2], 2))
+    print(s.maximumJumps([1, 3, 6, 4, 1, 2], 3))
+    print(s.maximumJumps([1, 3, 6, 4, 1, 2], 0))
+
+"""
+ 给你一个下标从 0 开始、由 n 个整数组成的数组 nums 和一个整数 target 。
+
+你的初始位置在下标 0 。在一步操作中，你可以从下标 i 跳跃到任意满足下述条件的下标 j ：
+
+0 <= i < j < n
+-target <= nums[j] - nums[i] <= target
+返回到达下标 n - 1 处所需的 最大跳跃次数 。
+
+如果无法到达下标 n - 1 ，返回 -1 。
+
+ 
+
+示例 1：
+
+输入：nums = [1,3,6,4,1,2], target = 2
+输出：3
+解释：要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
+- 从下标 0 跳跃到下标 1 。
+- 从下标 1 跳跃到下标 3 。
+- 从下标 3 跳跃到下标 5 。
+可以证明，从 0 到 n - 1 的所有方案中，不存在比 3 步更长的跳跃序列。因此，答案是 3 。
+示例 2：
+
+输入：nums = [1,3,6,4,1,2], target = 3
+输出：5
+解释：要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作：
+- 从下标 0 跳跃到下标 1 。
+- 从下标 1 跳跃到下标 2 。
+- 从下标 2 跳跃到下标 3 。
+- 从下标 3 跳跃到下标 4 。
+- 从下标 4 跳跃到下标 5 。
+可以证明，从 0 到 n - 1 的所有方案中，不存在比 5 步更长的跳跃序列。因此，答案是 5 。
+示例 3：
+
+输入：nums = [1,3,6,4,1,2], target = 0
+输出：-1
+解释：可以证明不存在从 0 到 n - 1 的跳跃序列。因此，答案是 -1 。
+ 
+
+提示：
+
+2 <= nums.length == n <= 1000
+-109 <= nums[i] <= 109
+0 <= target <= 2 * 109
+
+来源：力扣（LeetCode）
+链接：https://leetcode.cn/problems/maximum-number-of-jumps-to-reach-the-last-index
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+"""