533-545-604-624-656-663-734-760-800-966 (10)

Author: gdut-yy

leetcode-06/src/main/java/Solution533.java

@@ -0,0 +1,70 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution533 {
+    // 531
+    public int findBlackPixel(char[][] picture, int target) {
+        int m = picture.length;
+        int n = picture[0].length;
+        // 预处理
+        int[] cols = new int[n];
+        for (char[] chars : picture) {
+            for (int j = 0; j < n; j++) {
+                if (chars[j] == 'B') {
+                    cols[j]++;
+                }
+            }
+        }
+        // 相同行进行合并计数 [B的数量, 相同行数]
+        Map<String, int[]> cntMap = new HashMap<>();
+        for (char[] chars : picture) {
+            String key = new String(chars);
+            if (cntMap.containsKey(key)) {
+                cntMap.get(key)[1]++;
+            } else {
+                int cntB = 0;
+                for (char ch : chars) {
+                    if (ch == 'B') {
+                        cntB++;
+                    }
+                }
+                cntMap.put(key, new int[]{cntB, 1});
+            }
+        }
+
+        int res = 0;
+        for (Map.Entry<String, int[]> entry : cntMap.entrySet()) {
+            String key = entry.getKey();
+            int[] tuple = entry.getValue();
+            // 行满足要求
+            if (tuple[0] == target && tuple[1] == target) {
+                for (int j = 0; j < n; j++) {
+                    // 列满足要求
+                    if (key.charAt(j) == 'B' && cols[j] == target) {
+                        res++;
+                    }
+                }
+            }
+        }
+        return res * target;
+    }
+}
+/*
+$533. 孤独像素 II
+https://leetcode.cn/problems/lonely-pixel-ii/
+
+给你一个大小为 m x n 的二维字符数组 picture ，表示一张黑白图像，数组中的 'B' 表示黑色像素，'W' 表示白色像素。另给你一个整数 target ，请你找出并返回符合规则的 黑色 孤独像素的数量。
+黑色孤独像素是指位于某一特定位置 (r, c) 的字符 'B' ，其中：
+- 行 r 和列 c 中的黑色像素恰好有 target 个。
+- 列 c 中所有黑色像素所在的行必须和行 r 完全相同。
+提示：
+m == picture.length
+n == picture[i].length
+1 <= m, n <= 200
+picture[i][j] 为 'W' 或 'B'
+1 <= target <= min(m, n)
+
+难度升级，条件二的意思是 满足要求的行全部相同，因此要将相同的行进行预处理。
+相似题目: $531. 孤独像素 I
+https://leetcode.cn/problems/lonely-pixel-i/
+ */

leetcode-06/src/main/java/Solution545.java

@@ -0,0 +1,84 @@
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+
+public class Solution545 {
+    public List<Integer> boundaryOfBinaryTree(TreeNode root) {
+        List<Integer> resList = new ArrayList<>();
+        if (root == null) {
+            return resList;
+        }
+
+        if (!isLeaf(root)) {
+            resList.add(root.val);
+        }
+        TreeNode t = root.left;
+        while (t != null) {
+            if (!isLeaf(t)) {
+                resList.add(t.val);
+            }
+            if (t.left != null) {
+                t = t.left;
+            } else {
+                t = t.right;
+            }
+        }
+        addLeaves(root, resList);
+
+        Deque<Integer> stack = new ArrayDeque<>();
+        t = root.right;
+        while (t != null) {
+            if (!isLeaf(t)) {
+                stack.push(t.val);
+            }
+            if (t.right != null) {
+                t = t.right;
+            } else {
+                t = t.left;
+            }
+        }
+        while (!stack.isEmpty()) {
+            resList.add(stack.pop());
+        }
+        return resList;
+    }
+
+    private boolean isLeaf(TreeNode node) {
+        return node.left == null && node.right == null;
+    }
+
+    private void addLeaves(TreeNode node, List<Integer> resList) {
+        if (isLeaf(node)) {
+            resList.add(node.val);
+        } else {
+            if (node.left != null) {
+                addLeaves(node.left, resList);
+            }
+            if (node.right != null) {
+                addLeaves(node.right, resList);
+            }
+        }
+    }
+}
+/*
+$545. 二叉树的边界
+https://leetcode.cn/problems/boundary-of-binary-tree/
+
+二叉树的 边界 是由 根节点 、左边界 、按从左到右顺序的 叶节点 和 逆序的右边界 ，按顺序依次连接组成。
+左边界 是满足下述定义的节点集合：
+- 根节点的左子节点在左边界中。如果根节点不含左子节点，那么左边界就为 空 。
+- 如果一个节点在左边界中，并且该节点有左子节点，那么它的左子节点也在左边界中。
+- 如果一个节点在左边界中，并且该节点 不含 左子节点，那么它的右子节点就在左边界中。
+- 最左侧的叶节点 不在 左边界中。
+右边界 定义方式与 左边界 相同，只是将左替换成右。即，右边界是根节点右子树的右侧部分；叶节点 不是 右边界的组成部分；如果根节点不含右子节点，那么右边界为 空 。
+叶节点 是没有任何子节点的节点。对于此问题，根节点 不是 叶节点。
+给你一棵二叉树的根节点 root ，按顺序返回组成二叉树 边界 的这些值。
+提示：
+树中节点的数目在范围 [1, 10^4] 内
+-1000 <= Node.val <= 1000
+
+模拟。将问题划分成三个子问题：左边界、叶子节点和右边界。
+时间复杂度 O(n)
+空间复杂度 O(n)
+ */

leetcode-06/src/test/java/Solution533Tests.java

@@ -0,0 +1,26 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution533Tests {
+    private final Solution533 solution533 = new Solution533();
+
+    @Test
+    public void example1() {
+        char[][] picture = UtUtils.stringToChars2("""
+                [["W","B","W","B","B","W"],["W","B","W","B","B","W"],["W","B","W","B","B","W"],["W","W","B","W","B","W"]]
+                """);
+        int target = 3;
+        int expected = 6;
+        Assertions.assertEquals(expected, solution533.findBlackPixel(picture, target));
+    }
+
+    @Test
+    public void example2() {
+        char[][] picture = UtUtils.stringToChars2("""
+                [["W","W","B"],["W","W","B"],["W","W","B"]]
+                """);
+        int target = 1;
+        int expected = 0;
+        Assertions.assertEquals(expected, solution533.findBlackPixel(picture, target));
+    }
+}

leetcode-06/src/test/java/Solution545Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+public class Solution545Tests {
+    private final Solution545 solution545 = new Solution545();
+
+    @Test
+    public void example1() {
+        TreeNode root = TreeNode.buildTreeNode("[1,null,2,3,4]");
+        List<Integer> expected = List.of(1, 3, 4, 2);
+        Assertions.assertEquals(expected, solution545.boundaryOfBinaryTree(root));
+    }
+
+    @Test
+    public void example2() {
+        TreeNode root = TreeNode.buildTreeNode("[1,2,3,4,5,6,null,null,null,7,8,9,10]");
+        List<Integer> expected = List.of(1, 2, 4, 7, 8, 9, 10, 6, 3);
+        Assertions.assertEquals(expected, solution545.boundaryOfBinaryTree(root));
+    }
+}

leetcode-07/src/main/java/Solution604.java

@@ -0,0 +1,52 @@
+public class Solution604 {
+    static class StringIterator {
+        private final String compressedString;
+        private final int N;
+        private int iterator;
+        private char ch;
+        private int cnt;
+
+        public StringIterator(String compressedString) {
+            this.compressedString = compressedString;
+            N = compressedString.length();
+            iterator = 0;
+            ch = ' ';
+            cnt = 0;
+        }
+
+        public char next() {
+            if (!hasNext()) {
+                return ' ';
+            }
+            if (cnt == 0) {
+                ch = compressedString.charAt(iterator++);
+                while (iterator < N && Character.isDigit(compressedString.charAt(iterator))) {
+                    cnt = cnt * 10 + compressedString.charAt(iterator) - '0';
+                    iterator++;
+                }
+            }
+            cnt--;
+            return ch;
+        }
+
+        public boolean hasNext() {
+            return iterator != N || cnt != 0;
+        }
+    }
+}
+/*
+$604. 迭代压缩字符串
+https://leetcode.cn/problems/design-compressed-string-iterator/
+
+设计并实现一个迭代压缩字符串的数据结构。给定的压缩字符串的形式是，每个字母后面紧跟一个正整数，表示该字母在原始未压缩字符串中出现的次数。
+设计一个数据结构，它支持如下两种操作： next 和 hasNext。
+- next() - 如果原始字符串中仍有未压缩字符，则返回下一个字符，否则返回空格。
+- hasNext() - 如果原始字符串中存在未压缩的的字母，则返回true，否则返回false。
+提示：
+1 <= compressedString.length <= 1000
+compressedString 由小写字母、大写字母和数字组成。
+在 compressedString 中，单个字符的重复次数在 [1,10 ^9] 范围内。
+next 和 hasNext 的操作数最多为 100 。
+
+按需计算
+ */

leetcode-07/src/main/java/Solution624.java

@@ -0,0 +1,41 @@
+import java.util.List;
+
+public class Solution624 {
+    public int maxDistance(List<List<Integer>> arrays) {
+        int res = 0;
+        int sz = arrays.size();
+        List<Integer> array0 = arrays.get(0);
+        int min = array0.get(0);
+        int max = array0.get(array0.size() - 1);
+        for (int i = 1; i < sz; i++) {
+            List<Integer> arrayI = arrays.get(i);
+            int minI = arrayI.get(0);
+            int maxI = arrayI.get(arrayI.size() - 1);
+            res = Math.max(res, Math.max(maxI - min, max - minI));
+            min = Math.min(min, minI);
+            max = Math.max(max, maxI);
+        }
+        return res;
+    }
+}
+/*
+$624. 数组列表中的最大距离
+https://leetcode.cn/problems/maximum-distance-in-arrays/
+
+给定 m 个数组，每个数组都已经按照升序排好序了。现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。
+两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。你的任务就是去找到最大距离
+示例 1：
+输入：
+[[1,2,3],
+ [4,5],
+ [1,2,3]]
+输出： 4
+解释：
+一种得到答案 4 的方法是从第一个数组或者第三个数组中选择 1，同时从第二个数组中选择 5 。
+注意：
+每个给定数组至少会有 1 个数字。列表中至少有两个非空数组。
+所有 m 个数组中的数字总数目在范围 [2, 10000] 内。
+m 个数组中所有整数的范围在 [-10000, 10000] 内。
+
+扫描线
+ */

leetcode-07/src/main/java/Solution656.java

@@ -0,0 +1,58 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution656 {
+    public List<Integer> cheapestJump(int[] coins, int maxJump) {
+        int n = coins.length;
+        int[] next = new int[n];
+        Arrays.fill(next, -1);
+        // f[i] 表示从位置 i 跳到末尾的最小花费
+        long[] f = new long[n];
+
+        for (int i = n - 2; i >= 0; i--) {
+            long minCost = Integer.MAX_VALUE;
+            for (int j = i + 1; j <= i + maxJump && j < n; j++) {
+                if (coins[i] != -1) {
+                    long cost = coins[i] + f[j];
+                    if (minCost > cost) {
+                        minCost = cost;
+                        next[i] = j;
+                    }
+                }
+            }
+            f[i] = minCost;
+        }
+
+        List<Integer> resList = new ArrayList<>();
+        int i = 0;
+        for (; i < n && next[i] != -1; i = next[i]) {
+            resList.add(i + 1);
+        }
+        if (i == n - 1 && coins[i] != -1) {
+            resList.add(n);
+        } else {
+            // 如果无法到达 N 位置，请返回一个空数组
+            resList.clear();
+        }
+        return resList;
+    }
+}
+/*
+$656. 金币路径
+https://leetcode.cn/problems/coin-path/
+
+给定一个数组 A（下标从 1 开始）包含 N 个整数：A1，A2，……，AN 和一个整数 B。
+你可以从数组 A 中的任何一个位置（下标为 i）跳到下标 i+1，i+2，……，i+B 的任意一个可以跳到的位置上。
+如果你在下标为 i 的位置上，你需要支付 Ai 个金币。如果 Ai 是 -1，意味着下标为 i 的位置是不可以跳到的。
+现在，你希望花费最少的金币从数组 A 的 1 位置跳到 N 位置，你需要输出花费最少的路径，依次输出所有经过的下标（从 1 到 N）。
+如果有多种花费最少的方案，输出字典顺序最小的路径。
+如果无法到达 N 位置，请返回一个空数组。
+注释 :
+路径 Pa1，Pa2，……，Pan 是字典序小于 Pb1，Pb2，……，Pbm 的，当且仅当第一个 Pai 和 Pbi 不同的 i 满足 Pai < Pbi，如果不存在这样的 i 那么满足 n < m。
+A1 >= 0。 A2, ..., AN （如果存在） 的范围是 [-1, 100]。
+A 数组的长度范围 [1, 1000].
+B 的范围 [1, 100].
+
+动态规划
+ */