1255 & 第334场周赛T1~T4 (5)

Author: gdut-yy

leetcode-13/src/main/java/Solution1255.java

@@ -0,0 +1,70 @@
+public class Solution1255 {
+    public int maxScoreWords(String[] words, char[] letters, int[] score) {
+        int n = words.length;
+
+        // 预处理 fs[i] 表示第 i 个单词分数；cost[i] 表示第 i 个单词所需字母
+        int[] fs = new int[n];
+        int[][] cost = new int[n][26];
+        for (int i = 0; i < n; i++) {
+            int s = 0;
+            for (char ch : words[i].toCharArray()) {
+                cost[i][ch - 'a']++;
+                s += score[ch - 'a'];
+            }
+            fs[i] = s;
+        }
+        // tot 表示各字符可用的数量
+        int[] tot = new int[26];
+        for (char ch : letters) {
+            tot[ch - 'a']++;
+        }
+
+        int max = 0;
+        // 状态压缩
+        for (int mask = 1; mask < (1 << n); mask++) {
+            int[] need = new int[26];
+            int s = 0;
+            for (int k = 0; k < n; k++) {
+                if (((mask >> k) & 1) == 1) {
+                    for (int i = 0; i < 26; i++) {
+                        need[i] += cost[k][i];
+                        if (need[i] > tot[i]) {
+                            // 状态不成立
+                            s = -1;
+                            break;
+                        }
+                    }
+                    if (s < 0) break;
+                    s += fs[k];
+                }
+            }
+            max = Math.max(max, s);
+        }
+        return max;
+    }
+}
+/*
+1255. 得分最高的单词集合
+https://leetcode.cn/problems/maximum-score-words-formed-by-letters/
+
+你将会得到一份单词表 words，一个字母表 letters （可能会有重复字母），以及每个字母对应的得分情况表 score。
+请你帮忙计算玩家在单词拼写游戏中所能获得的「最高得分」：能够由 letters 里的字母拼写出的 任意 属于 words 单词子集中，分数最高的单词集合的得分。
+单词拼写游戏的规则概述如下：
+- 玩家需要用字母表 letters 里的字母来拼写单词表 words 中的单词。
+- 可以只使用字母表 letters 中的部分字母，但是每个字母最多被使用一次。
+- 单词表 words 中每个单词只能计分（使用）一次。
+- 根据字母得分情况表score，字母 'a', 'b', 'c', ... , 'z' 对应的得分分别为 score[0], score[1], ..., score[25]。
+- 本场游戏的「得分」是指：玩家所拼写出的单词集合里包含的所有字母的得分之和。
+提示：
+1 <= words.length <= 14
+1 <= words[i].length <= 15
+1 <= letters.length <= 100
+letters[i].length == 1
+score.length == 26
+0 <= score[i] <= 10
+words[i] 和 letters[i] 只包含小写的英文字母。
+
+状态压缩枚举
+时间复杂度 O(n * 2^n)
+空间复杂度 O(n)
+ */

leetcode-13/src/test/java/Solution1255Tests.java

@@ -0,0 +1,39 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1255Tests {
+    private final Solution1255 solution1255 = new Solution1255();
+
+    @Test
+    public void example1() {
+        String[] words = {"dog", "cat", "dad", "good"};
+        char[] letters = UtUtils.stringToChars("""
+                ["a","a","c","d","d","d","g","o","o"]
+                """);
+        int[] score = {1, 0, 9, 5, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        int expected = 23;
+        Assertions.assertEquals(expected, solution1255.maxScoreWords(words, letters, score));
+    }
+
+    @Test
+    public void example2() {
+        String[] words = {"xxxz", "ax", "bx", "cx"};
+        char[] letters = UtUtils.stringToChars("""
+                ["z","a","b","c","x","x","x"]
+                """);
+        int[] score = {4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 10};
+        int expected = 27;
+        Assertions.assertEquals(expected, solution1255.maxScoreWords(words, letters, score));
+    }
+
+    @Test
+    public void example3() {
+        String[] words = {"leetcode"};
+        char[] letters = UtUtils.stringToChars("""
+                ["l","e","t","c","o","d"]
+                """);
+        int[] score = {0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0};
+        int expected = 0;
+        Assertions.assertEquals(expected, solution1255.maxScoreWords(words, letters, score));
+    }
+}

leetcode-23/src/main/java/Solution2212.java

@@ -1,34 +1,34 @@
 public class Solution2212 {
     public int[] maximumBobPoints(int numArrows, int[] aliceArrows) {
-        int maxScore = 0;
-        int[] res = new int[12];
+        // 常数 12
+        int n = aliceArrows.length;
 
-        // 状态压缩 2^12 = 4096
-        for (int state = 0; state < (1 << 12); state++) {
-            // bob
+        int maxScore = 0;
+        int[] res = new int[n];
+        for (int mask = 0; mask < (1 << n); mask++) {
+            // bob 当前状态的分数，箭数，射箭情况
             int score = 0;
-            int arrows = numArrows;
-            int[] bobArrows = new int[12];
+            int need = 0;
+            int[] bobArrows = new int[n];
 
-            // 贪心，从分值高的开始
-            for (int k = 11; k >= 0; k--) {
-                // 第 k 位被选中
-                if (((state >> k) & 1) == 1) {
-                    int needArrows = aliceArrows[k] + 1;
-                    // can
-                    if (arrows - needArrows >= 0 && k != 0) {
-                        arrows -= needArrows;
-                        score += k;
-                        bobArrows[k] = needArrows;
-                    } else {
-                        bobArrows[k] = arrows;
-                        arrows = 0;
+            // 从分值高的开始
+            for (int k = n - 1; k >= 1; k--) {
+                if (((mask >> k) & 1) == 1) {
+                    bobArrows[k] = aliceArrows[k] + 1;
+                    need += bobArrows[k];
+                    if (need > numArrows) {
+                        // 状态不成立
+                        score = -1;
+                        break;
                     }
+                    score += k;
                 }
-                if (score >= maxScore) {
-                    maxScore = score;
-                    res = bobArrows;
-                }
+            }
+            if (maxScore < score) {
+                // 多余的箭全部射到 0 区域
+                bobArrows[0] = numArrows - need;
+                maxScore = score;
+                res = bobArrows;
             }
         }
         return res;

leetcode-26/src/main/java/Solution6366.java

@@ -0,0 +1,77 @@
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Solution6366 {
+    private static final int[][] DIRECTIONS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int minimumTime(int[][] grid) {
+        int M = grid.length;
+        int N = grid[0].length;
+
+        // “困毙”
+        if (grid[0][1] > 1 && grid[1][0] > 1) {
+            return -1;
+        }
+
+        PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(o -> o[2]));
+        queue.add(new int[]{0, 0, 0});
+        boolean[][] visited = new boolean[M][N];
+        // 到达 grid[i][j] 所需的最少时间
+        int[][] t = new int[M][N];
+        for (int i = 0; i < M; i++) {
+            Arrays.fill(t[i], Integer.MAX_VALUE);
+        }
+        t[0][0] = 0;
+        while (!queue.isEmpty()) {
+            int[] tuple = queue.remove();
+            int cx = tuple[0], cy = tuple[1], ct = tuple[2];
+            if (visited[cx][cy]) {
+                continue;
+            }
+            visited[cx][cy] = true;
+
+            for (int[] dir : DIRECTIONS) {
+                int nx = cx + dir[0];
+                int ny = cy + dir[1];
+                if (nx >= 0 && nx < M && ny >= 0 && ny < N) {
+                    // “走闲”
+                    int nt = ct + 1 + (Math.max(0, grid[nx][ny] - ct) / 2 * 2);
+                    if (t[nx][ny] > nt) {
+                        t[nx][ny] = nt;
+                        queue.add(new int[]{nx, ny, nt});
+                    }
+                }
+            }
+        }
+        return t[M - 1][N - 1];
+    }
+}
+/*
+6366. 在网格图中访问一个格子的最少时间
+https://leetcode.cn/problems/minimum-time-to-visit-a-cell-in-a-grid/
+
+第 334 场周赛 T4。
+
+给你一个 m x n 的矩阵 grid ，每个元素都为 非负 整数，其中 grid[row][col] 表示可以访问格子 (row, col) 的 最早 时间。
+也就是说当你访问格子 (row, col) 时，最少已经经过的时间为 grid[row][col] 。
+你从 最左上角 出发，出发时刻为 0 ，你必须一直移动到上下左右相邻四个格子中的 任意 一个格子（即不能停留在格子上）。每次移动都需要花费 1 单位时间。
+请你返回 最早 到达右下角格子的时间，如果你无法到达右下角的格子，请你返回 -1 。
+提示：
+m == grid.length
+n == grid[i].length
+2 <= m, n <= 1000
+4 <= m * n <= 10^5
+0 <= grid[i][j] <= 10^5
+grid[0][0] == 0
+
+堆优化 Dijkstra 最短路。
+首先，特判 `grid[0][1] > 1 && grid[1][0] > 1` 情况，此时“困毙”（“困毙”：中国象棋术语。指轮到行棋的一方，棋子没有被将军，但所有棋子被困在原地无子可动，即被困毙）。
+否则，可以通过“走闲”来凑时间，总能到达终点（“走闲”：中国象棋术语。表示行棋方无意进攻，走闲是用于等待时机或用于防守的战术）。
+注意时间奇偶性：因“走闲”一次时间 +2。如：3->5 需要 t+2+1；3->6 同样需要 t+2+1。
+最后 dijkstra 求最短路即可。
+时间复杂度 O(mnlogmn)
+本题还有二分 + BFS 解法。
+相似题目: 778. 水位上升的泳池中游泳
+https://leetcode.cn/problems/swim-in-rising-water/
+ */

leetcode-26/src/main/java/Solution6367.java

@@ -0,0 +1,51 @@
+import java.util.Arrays;
+
+public class Solution6367 {
+    public int maxNumOfMarkedIndices(int[] nums) {
+        int n = nums.length;
+        Arrays.sort(nums);
+
+        int left = 1;
+        int right = n / 2 + 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            // 边界二分 F, F,..., F, [T, T,..., T]
+            // ----------------------^
+            if (!checkMid(nums, mid)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return (left - 1) * 2;
+    }
+
+    // 是否可以构造 k 对匹配（最小 k 个数和最大 k 个数 一一匹配）
+    private boolean checkMid(int[] nums, int k) {
+        int n = nums.length;
+        for (int i = 0; i < k; i++) {
+            if (nums[i] * 2 > nums[n - k + i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+/*
+6367. 求出最多标记下标
+https://leetcode.cn/problems/find-the-maximum-number-of-marked-indices/
+
+第 334 场周赛 T3。
+
+给你一个下标从 0 开始的整数数组 nums 。
+一开始，所有下标都没有被标记。你可以执行以下操作任意次：
+- 选择两个 互不相同且未标记 的下标 i 和 j ，满足 2 * nums[i] <= nums[j] ，标记下标 i 和 j 。
+请你执行上述操作任意次，返回 nums 中最多可以标记的下标数目。
+提示：
+1 <= nums.length <= 10^5
+1 <= nums[i] <= 10^9
+
+二分 + 贪心。
+二分查找转化为判定问题：判定是否可以构造 k 对匹配。根据贪心：当最小 k 个数和最大 k 个数一一匹配时，配对数最大。
+时间复杂度 O(nlogn)
+ */

leetcode-26/src/main/java/Solution6368.java

@@ -0,0 +1,37 @@
+public class Solution6368 {
+    public int[] divisibilityArray(String word, int m) {
+        int n = word.length();
+
+        long x = 0L;
+        int[] div = new int[n];
+        for (int i = 0; i < n; i++) {
+            x = x * 10 + (word.charAt(i) - '0');
+            if (x % m == 0) {
+                div[i] = 1;
+            }
+            x %= m;
+        }
+        return div;
+    }
+}
+/*
+6368. 找出字符串的可整除数组
+https://leetcode.cn/problems/find-the-divisibility-array-of-a-string/
+
+第 334 场周赛 T2。
+
+给你一个下标从 0 开始的字符串 word ，长度为 n ，由从 0 到 9 的数字组成。另给你一个正整数 m 。
+word 的 可整除数组 div 是一个长度为 n 的整数数组，并满足：
+- 如果 word[0,...,i] 所表示的 数值 能被 m 整除，div[i] = 1
+- 否则，div[i] = 0
+返回 word 的可整除数组。
+提示：
+1 <= n <= 10^5
+word.length == n
+word 由数字 0 到 9 组成
+1 <= m <= 10^9
+
+贪心。模运算。
+如果 x 可以整除 m，那么 x * 10 也必然可以整除 m。取余之后不影响结果。
+时间复杂度 O(n)
+ */

leetcode-26/src/main/java/Solution6369.java

@@ -0,0 +1,39 @@
+public class Solution6369 {
+    public int[] leftRigthDifference(int[] nums) {
+        int n = nums.length;
+
+        // 前缀和
+        int[] preSum = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            preSum[i + 1] = preSum[i] + nums[i];
+        }
+
+        int[] ans = new int[n];
+        for (int i = 0; i < n; i++) {
+            int leftSum = preSum[i];
+            int rightSum = preSum[n] - preSum[i + 1];
+            ans[i] = Math.abs(leftSum - rightSum);
+        }
+        return ans;
+    }
+}
+/*
+6369. 左右元素和的差值
+https://leetcode.cn/problems/left-and-right-sum-differences/
+
+第 334 场周赛 T1。
+
+给你一个下标从 0 开始的整数数组 nums ，请你找出一个下标从 0 开始的整数数组 answer ，其中：
+- answer.length == nums.length
+- answer[i] = |leftSum[i] - rightSum[i]|
+其中：
+- leftSum[i] 是数组 nums 中下标 i 左侧元素之和。如果不存在对应的元素，leftSum[i] = 0 。
+- rightSum[i] 是数组 nums 中下标 i 右侧元素之和。如果不存在对应的元素，rightSum[i] = 0 。
+返回数组 answer 。
+提示：
+1 <= nums.length <= 1000
+1 <= nums[i] <= 10^5
+
+前缀和。leftSum[i] = [0,i-1] 区间和；rightSum[i] = [i+1,n-1] 区间和。
+时间复杂度 O(n)
+ */