3476-3481-3491-3496-3506-3520-3526-3535-3540-3549 (10)

Author: gdut-yy

leetcode/leetcode-35/src/main/java/SolutionP3476.java

@@ -0,0 +1,43 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SolutionP3476 {
+ public long maxProfit(int[] workers, int[][] tasks) {
+ Map<Integer, List<Integer>> groupTasks = new HashMap<>(); // 按 task[0] 分组
+ for (int[] ta : tasks) groupTasks.computeIfAbsent(ta[0], e -> new ArrayList<>()).add(ta[1]);
+ for (List<Integer> vals : groupTasks.values()) vals.sort(null);
+
+ long ans = 0;
+ for (int wo : workers) {
+ if (!groupTasks.containsKey(wo)) continue;
+ ans += groupTasks.get(wo).removeLast();
+ if (groupTasks.get(wo).isEmpty()) groupTasks.remove(wo);
+ }
+ int maxTask = 0;
+ for (List<Integer> vals : groupTasks.values()) {
+ maxTask = Math.max(maxTask, vals.getLast());
+ }
+ return ans + maxTask;
+ }
+}
+/*
+$3476. 最大化任务分配的利润
+https://leetcode.cn/problems/maximize-profit-from-task-assignment/description/
+
+给定一个整数数组 workers，其中 workers[i] 表示第 i 个工人的技能等级。同时给定一个 2 维数组 tasks，其中：
+- tasks[i][0] 表示完成任务所需的技能要求。
+- tasks[i][1] 表示完成任务的收益。
+每一个工人 最多 能完成一个任务，并且只有在他们的技能等级 等于 任务的技能要求时才能获取此任务。今天又有一名 额外 工人加入，他可以承接任何任务，无论 技能要求如何。
+返回按照最优方式分配任务给工人所能获得的 最大 总利润。
+提示：
+1 <= workers.length <= 10^5
+1 <= workers[i] <= 10^9
+1 <= tasks.length <= 10^5
+tasks[i].length == 2
+1 <= tasks[i][0], tasks[i][1] <= 10^9
+
+分组 + 贪心。
+时间复杂度 O(nlogn)。
+ */

leetcode/leetcode-35/src/main/java/SolutionP3481.java

@@ -0,0 +1,56 @@
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SolutionP3481 {
+ private Map<Character, String> replace;
+ private Map<String, String> memo;
+
+ public String applySubstitutions(List<List<String>> replacements, String text) {
+ replace = new HashMap<>();
+ for (List<String> re : replacements) {
+ replace.put(re.get(0).charAt(0), re.get(1));
+ }
+ memo = new HashMap<>();
+ return dfs(text);
+ }
+
+ private String dfs(String s) {
+ if (memo.containsKey(s)) return memo.get(s);
+ StringBuilder sb = new StringBuilder();
+ int i = 0, n = s.length();
+ while (i < n) {
+ if (s.charAt(i) != '%') {
+ sb.append(s.charAt(i));
+ i += 1;
+ } else {
+ sb.append(dfs(replace.get(s.charAt(i + 1))));
+ i += 3;
+ }
+ }
+ String res = sb.toString();
+ memo.put(s, res);
+ return res;
+ }
+}
+/*
+$3481. 应用替换
+https://leetcode.cn/problems/apply-substitutions/description/
+
+给定一个 replacements 映射和一个可能包含格式为 %var% 占位符 的字符串 text，其中每个 var 对应 replacements 中的一个键。每个替换值本身可能包含 一个或多个 此类占位符。每个 占位符 都被与其相应的替换键对应的值替换。
+返回完全替换后 不 含任何 占位符 的 text 字符串。
+提示：
+1 <= replacements.length <= 10
+replacements 中的每个元素是一个双值列表 [key, value]，其中：
+ key 是一个大写英语字母。
+ value 是一个最多有 8 个字符，可能包含 0 个或更多格式为 %<key>% 的占位符的非空字符串。
+所有的替换键互不相同。
+text 字符串是通过从替换映射中随机串联所有 key 占位符（格式为 %<key>%）而形成的，以虚线分隔。
+text.length == 4 * replacements.length - 1
+text 或任何替换值中的每个占位符对应 replacements 映射中的一个键。
+替换键之间没有循环依赖。
+
+记忆化搜索。
+https://leetcode.cn/problems/apply-substitutions/solutions/3680990/ji-yi-hua-sou-suo-by-endlesscheng-kn4j/
+时间复杂度：O(L * 2^n)。其中 L <= 8。
+ */

leetcode/leetcode-35/src/main/java/SolutionP3491.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+
+public class SolutionP3491 {
+ public boolean phonePrefix(String[] numbers) {
+ int n = numbers.length;
+ Arrays.sort(numbers);
+ for (int i = 1; i < n; i++) {
+ if (numbers[i].startsWith(numbers[i - 1])) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+/*
+$3491. 电话号码前缀
+https://leetcode.cn/problems/phone-number-prefix/description/
+
+给定一个字符串数组 numbers 表示电话号码。如果没有电话号码是任何其他电话号码的前缀，则返回 true；否则，返回 false。
+提示：
+2 <= numbers.length <= 50
+1 <= numbers[i].length <= 50
+所有数字只包含 '0' 到 '9' 的数位。
+
+排序后一定相邻。
+时间复杂度 O(nlogn * L)。
+ */

leetcode/leetcode-35/src/main/java/SolutionP3496.java

@@ -0,0 +1,31 @@
+public class SolutionP3496 {
+ public int maxScore(int[] nums) {
+ int n = nums.length;
+ int sum = nums[0], minSingle = nums[0], minPair = Integer.MAX_VALUE; // 奇数长度剩下一个, 偶数长度剩下相邻的一对
+ for (int i = 1; i < n; i++) {
+ sum += nums[i];
+ minSingle = Math.min(minSingle, nums[i]);
+ minPair = Math.min(minPair, nums[i] + nums[i - 1]);
+ }
+ if (n % 2 == 1) return sum - minSingle;
+ return sum - minPair;
+ }
+}
+/*
+$3496. 最大化配对删除后的得分
+https://leetcode.cn/problems/maximize-score-after-pair-deletions/description/
+
+给定一个整数数组 nums。当数组中元素超过两个时，你 必须 重复执行以下操作中的一个：
+- 删除最前面的两个元素。
+- 删除最后面的两个元素。
+- 删除第一和最后一个元素。
+对于每次操作，将移除的元素之和加到你的总分上。
+返回你可以达到的 最高 分数。
+提示：
+1 <= nums.length <= 10^5
+-10^4 <= nums[i] <= 10^4
+
+脑筋急转弯。
+奇数长度剩下一个, 偶数长度剩下相邻的一对
+时间复杂度 O(n)。
+ */

leetcode/leetcode-35/src/test/java/SolutionP3476Tests.java

@@ -0,0 +1,30 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class SolutionP3476Tests {
+ private final SolutionP3476 solutionP3476 = new SolutionP3476();
+
+ @Test
+ public void example1() {
+ int[] workers = {1, 2, 3, 4, 5};
+ int[][] tasks = UtUtils.stringToInts2("[[1,100],[2,400],[3,100],[3,400]]");
+ long expected = 1000;
+ Assertions.assertEquals(expected, solutionP3476.maxProfit(workers, tasks));
+ }
+
+ @Test
+ public void example2() {
+ int[] workers = {10, 10000, 100000000};
+ int[][] tasks = UtUtils.stringToInts2("[[1,100]]");
+ long expected = 100;
+ Assertions.assertEquals(expected, solutionP3476.maxProfit(workers, tasks));
+ }
+
+ @Test
+ public void example3() {
+ int[] workers = {7};
+ int[][] tasks = UtUtils.stringToInts2("[[3,3],[3,3]]");
+ long expected = 3;
+ Assertions.assertEquals(expected, solutionP3476.maxProfit(workers, tasks));
+ }
+}

leetcode/leetcode-35/src/test/java/SolutionP3481Tests.java

@@ -0,0 +1,28 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+public class SolutionP3481Tests {
+ private final SolutionP3481 solutionP3481 = new SolutionP3481();
+
+ @Test
+ public void example1() {
+ List<List<String>> replacements = UtUtils.stringToStringList2("""
+ [["A","abc"],["B","def"]]
+ """);
+ String text = "%A%_%B%";
+ String expected = "abc_def";
+ Assertions.assertEquals(expected, solutionP3481.applySubstitutions(replacements, text));
+ }
+
+ @Test
+ public void example2() {
+ List<List<String>> replacements = UtUtils.stringToStringList2("""
+ [["A","bce"],["B","ace"],["C","abc%B%"]]
+ """);
+ String text = "%A%_%B%_%C%";
+ String expected = "bce_ace_abcace";
+ Assertions.assertEquals(expected, solutionP3481.applySubstitutions(replacements, text));
+ }
+}

leetcode/leetcode-35/src/test/java/SolutionP3491Tests.java

@@ -0,0 +1,18 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class SolutionP3491Tests {
+ private final SolutionP3491 solutionP3491 = new SolutionP3491();
+
+ @Test
+ public void example1() {
+ String[] numbers = {"1", "2", "4", "3"};
+ Assertions.assertTrue(solutionP3491.phonePrefix(numbers));
+ }
+
+ @Test
+ public void example2() {
+ String[] numbers = {"001", "007", "15", "00153"};
+ Assertions.assertFalse(solutionP3491.phonePrefix(numbers));
+ }
+}

leetcode/leetcode-35/src/test/java/SolutionP3496Tests.java

@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class SolutionP3496Tests {
+ private final SolutionP3496 solutionP3496 = new SolutionP3496();
+
+ @Test
+ public void example1() {
+ int[] nums = {2, 4, 1};
+ int expected = 6;
+ Assertions.assertEquals(expected, solutionP3496.maxScore(nums));
+ }
+
+ @Test
+ public void example2() {
+ int[] nums = {5, -1, 4, 2};
+ int expected = 7;
+ Assertions.assertEquals(expected, solutionP3496.maxScore(nums));
+ }
+}

leetcode/leetcode-35/src/test/resources/solution3416-example4-input.txt

@@ -0,0 +1,38 @@
+import java.util.PriorityQueue;
+
+public class SolutionP3506 {
+ public long minEliminationTime(int[] timeReq, int splitTime) {
+ PriorityQueue<Long> pq = new PriorityQueue<>();
+ for (long time : timeReq) {
+ pq.add(time);
+ }
+ while (pq.size() > 1) {
+ pq.remove();
+ long secondMin = pq.remove();
+ pq.offer(secondMin + splitTime);
+ }
+ return pq.remove();
+ }
+}
+/*
+$3506. 查找消除细菌菌株所需时间
+https://leetcode.cn/problems/find-time-required-to-eliminate-bacterial-strains/description/
+
+给定一个整数数组 timeReq 和一个整数 splitTime。
+在人体微观世界中，免疫系统面临着一项非凡的挑战：对抗快速繁殖的细菌群落，这对身体的生存构成威胁。
+最初，只部署一个 白细胞（WBC）来消除细菌。然而，单独的白细胞很快意识到它无法跟上细菌的生长速度。
+WBC制定了一种巧妙的策略来对抗细菌：
+- 第 i 个细菌菌株需要 timeReq[i] 个时间单位来被消除。
+- 单个白细胞只能消除 一个 细菌菌株。之后，白细胞耗尽，无法执行任何其他任务。
+- 一个白细胞可以将自身分裂为两个白细胞，但这需要 splitTime 单位时间。一旦分裂，两个白细胞就可以 并行 消灭细菌。
+- 一个白细胞仅可以攻击一个细菌菌株。多个白细胞不能同时攻击一个菌株。
+您必须确定消除所有细菌菌株所需的 最短 时间。
+注意，细菌菌株可以按任何顺序消除。
+提示：
+2 <= timeReq.length <= 10^5
+1 <= timeReq[i] <= 10^9
+1 <= splitTime <= 10^9
+
+相似题目: $1199. 建造街区的最短时间
+https://leetcode.cn/problems/minimum-time-to-build-blocks/
+ */