588-711-781-1121-1933 (5)

gdut-yy · gdut-yy · commit 77f926c290a5 · 2023-01-27T20:49:07.000+08:00
diff --git a/leetcode-06/src/main/java/Solution588.java b/leetcode-06/src/main/java/Solution588.java
@@ -0,0 +1,100 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution588 {
+    static class FileSystem {
+        private final File root;
+
+        public FileSystem() {
+            root = new File();
+        }
+
+        public List<String> ls(String path) {
+            File f = root;
+            List<String> files = new ArrayList<>();
+            if (!path.equals("/")) {
+                String[] dirs = path.split("/");
+                for (int i = 1; i < dirs.length; i++) {
+                    f = f.files.get(dirs[i]);
+                }
+                if (f.isFile) {
+                    files.add(dirs[dirs.length - 1]);
+                    return files;
+                }
+            }
+            files = new ArrayList<>(f.files.keySet());
+            Collections.sort(files);
+            return files;
+        }
+
+        public void mkdir(String path) {
+            File f = root;
+            String[] dirs = path.split("/");
+            for (int i = 1; i < dirs.length; i++) {
+                if (!f.files.containsKey(dirs[i])) {
+                    f.files.put(dirs[i], new File());
+                }
+                f = f.files.get(dirs[i]);
+            }
+        }
+
+        public void addContentToFile(String filePath, String content) {
+            File f = root;
+            String[] dirs = filePath.split("/");
+            for (int i = 1; i < dirs.length - 1; i++) {
+                f = f.files.get(dirs[i]);
+            }
+            if (!f.files.containsKey(dirs[dirs.length - 1])) {
+                f.files.put(dirs[dirs.length - 1], new File());
+            }
+            f = f.files.get(dirs[dirs.length - 1]);
+            f.isFile = true;
+            f.content = f.content + content;
+        }
+
+        public String readContentFromFile(String filePath) {
+            File f = root;
+            String[] dirs = filePath.split("/");
+            for (int i = 1; i < dirs.length - 1; i++) {
+                f = f.files.get(dirs[i]);
+            }
+            return f.files.get(dirs[dirs.length - 1]).content;
+        }
+
+        // 字典树 使用统一的文件夹文件列表
+        private static class File {
+            boolean isFile = false;
+            Map<String, File> files = new HashMap<>();
+            String content = "";
+        }
+    }
+}
+/*
+$588. 设计内存文件系统
+https://leetcode.cn/problems/design-in-memory-file-system/
+
+设计一个内存文件系统，模拟以下功能：
+实现文件系统类:
+- FileSystem() 初始化系统对象
+- List<String> ls(String path)
+  - 如果 path 是一个文件路径，则返回一个仅包含该文件名称的列表。
+  - 如果 path 是一个目录路径，则返回该目录中文件和 目录名 的列表。
+答案应该 按字典顺序 排列。
+- void mkdir(String path) 根据给定的路径创建一个新目录。给定的目录路径不存在。如果路径中的中间目录不存在，您也应该创建它们。
+- void addContentToFile(String filePath, String content)
+  - 如果 filePath 不存在，则创建包含给定内容 content的文件。
+  - 如果 filePath 已经存在，将给定的内容 content附加到原始内容。
+- String readContentFromFile(String filePath) 返回 filePath下的文件内容。
+注意:
+1 <= path.length, filePath.length <= 100
+path 和 filePath 都是绝对路径，除非是根目录 ‘/’ 自身，其他路径都是以 ‘/’ 开头且 不 以 ‘/’ 结束。
+你可以假定所有操作的参数都是有效的，即用户不会获取不存在文件的内容，或者获取不存在文件夹和文件的列表。
+你可以假定所有文件夹名字和文件名字都只包含小写字母，且同一文件夹下不会有相同名字的文件夹或文件。
+1 <= content.length <= 50
+ls, mkdir, addContentToFile, and readContentFromFile 最多被调用 300 次
+
+字典树 使用统一的文件夹文件列表
+ */
diff --git a/leetcode-06/src/test/java/Solution588Tests.java b/leetcode-06/src/test/java/Solution588Tests.java
@@ -0,0 +1,24 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+public class Solution588Tests {
+    @Test
+    public void example1() {
+        Solution588.FileSystem fileSystem = new Solution588.FileSystem();
+
+        // 返回 []
+        Assertions.assertEquals(List.of(), fileSystem.ls("/"));
+
+        fileSystem.mkdir("/a/b/c");
+
+        fileSystem.addContentToFile("/a/b/c/d", "hello");
+
+        // 返回 ["a"]
+        Assertions.assertEquals(List.of("a"), fileSystem.ls("/"));
+
+        // 返回 "hello"
+        Assertions.assertEquals("hello", fileSystem.readContentFromFile("/a/b/c/d"));
+    }
+}
diff --git a/leetcode-08/src/main/java/Solution711.java b/leetcode-08/src/main/java/Solution711.java
@@ -0,0 +1,97 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution711 {
+    private int[][] grid;
+    private int M;
+    private int N;
+    private boolean[][] visited;
+    private List<Integer> shape;
+
+    public int numDistinctIslands2(int[][] grid) {
+        this.grid = grid;
+        M = grid.length;
+        N = grid[0].length;
+        visited = new boolean[M][N];
+        Set<String> shapes = new HashSet<>();
+
+        for (int i = 0; i < M; i++) {
+            for (int j = 0; j < N; j++) {
+                shape = new ArrayList<>();
+                explore(i, j);
+                if (!shape.isEmpty()) {
+                    shapes.add(canonical(shape));
+                }
+            }
+        }
+        return shapes.size();
+    }
+
+    private void explore(int i, int j) {
+        if (i >= 0 && i < M && j >= 0 && j < N && grid[i][j] == 1 && !visited[i][j]) {
+            visited[i][j] = true;
+            shape.add(i * N + j);
+            explore(i + 1, j);
+            explore(i - 1, j);
+            explore(i, j + 1);
+            explore(i, j - 1);
+        }
+    }
+
+    // 规范化哈希
+    private String canonical(List<Integer> shape) {
+        int sz = shape.size();
+        String ans = "";
+        int lift = M + N;
+        int[] out = new int[sz];
+        int[] xs = new int[sz];
+        int[] ys = new int[sz];
+
+        for (int c = 0; c < 8; c++) {
+            int t = 0;
+            for (int s : shape) {
+                int x = s / N;
+                int y = s % N;
+                // [x,y] [x,-y] [-x,y] [-x,-y]
+                // [y,x] [y,-x] [-y,x] [-y,-x]
+                xs[t] = c <= 1 ? x : (c <= 3 ? -x : (c <= 5 ? y : -y));
+                ys[t] = c <= 3 ? (c % 2 == 0 ? y : -y) : (c % 2 == 0 ? x : -x);
+                t++;
+            }
+
+            int mx = Arrays.stream(xs).min().orElseThrow();
+            int my = Arrays.stream(ys).min().orElseThrow();
+
+            for (int j = 0; j < sz; j++) {
+                out[j] = (xs[j] - mx) * lift + (ys[j] - my);
+            }
+            Arrays.sort(out);
+            String candidate = Arrays.toString(out);
+            if (ans.compareTo(candidate) < 0) {
+                ans = candidate;
+            }
+        }
+        return ans;
+    }
+}
+/*
+$711. 不同岛屿的数量 II
+https://leetcode.cn/problems/number-of-distinct-islands-ii/
+
+给定一个 m x n 二进制数组表示的网格 grid ，一个岛屿由 四连通 （上、下、左、右四个方向）的 1 组成（代表陆地）。你可以认为网格的四周被海水包围。
+如果两个岛屿的形状相同，或者通过旋转（顺时针旋转 90°，180°，270°）、翻转（左右翻转、上下翻转）后形状相同，那么就认为这两个岛屿是相同的。
+返回 这个网格中形状 不同 的岛屿的数量 。
+提示:
+m == grid.length
+n == grid[i].length
+1 <= m, n <= 50
+grid[i][j] 不是 0 就是 1.
+
+难度升级，可以旋转，翻转。
+规范性哈希。枚举 旋转+翻转 8 种情况的可能，用一个最小的矩形框住岛屿。
+相似题目: $694. 不同岛屿的数量
+https://leetcode.cn/problems/number-of-distinct-islands/
+ */
diff --git a/leetcode-08/src/main/java/Solution781.java b/leetcode-08/src/main/java/Solution781.java
@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution781 {
+    public int numRabbits(int[] answers) {
+        Map<Integer, Integer> cntMap = new HashMap<>();
+        for (int x : answers) {
+            cntMap.put(x, cntMap.getOrDefault(x, 0) + 1);
+        }
+
+        int res = 0;
+        for (Map.Entry<Integer, Integer> entry : cntMap.entrySet()) {
+            int x = entry.getKey();
+            int y = entry.getValue();
+            // ceil(y/(x+1)) * (x+1)
+            res += (y + x) / (x + 1) * (x + 1);
+        }
+        return res;
+    }
+}
+/*
+781. 森林中的兔子
+https://leetcode.cn/problems/rabbits-in-forest/
+
+森林中有未知数量的兔子。提问其中若干只兔子 "还有多少只兔子与你（指被提问的兔子）颜色相同?" ，将答案收集到一个整数数组 answers 中，其中 answers[i] 是第 i 只兔子的回答。
+给你数组 answers ，返回森林中兔子的最少数量。
+提示：
+1 <= answers.length <= 1000
+0 <= answers[i] < 1000
+
+HashMap 统计后分组，由于可能存在没有回答的兔子，需要向上取值。
+ */
diff --git a/leetcode-08/src/test/java/Solution711Tests.java b/leetcode-08/src/test/java/Solution711Tests.java
@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution711Tests {
+    private final Solution711 solution711 = new Solution711();
+
+    @Test
+    public void example1() {
+        int[][] grid = UtUtils.stringToInts2("[[1,1,0,0,0],[1,0,0,0,0],[0,0,0,0,1],[0,0,0,1,1]]");
+        int expected = 1;
+        Assertions.assertEquals(expected, solution711.numDistinctIslands2(grid));
+    }
+
+    @Test
+    public void example2() {
+        int[][] grid = UtUtils.stringToInts2("[[1,1,0,0,0],[1,1,0,0,0],[0,0,0,1,1],[0,0,0,1,1]]");
+        int expected = 1;
+        Assertions.assertEquals(expected, solution711.numDistinctIslands2(grid));
+    }
+}
diff --git a/leetcode-08/src/test/java/Solution781Tests.java b/leetcode-08/src/test/java/Solution781Tests.java
@@ -0,0 +1,37 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution781Tests {
+    private final Solution781 solution781 = new Solution781();
+
+    @Test
+    public void example1() {
+        int[] answers = {1, 1, 2};
+        int expected = 5;
+        Assertions.assertEquals(expected, solution781.numRabbits(answers));
+    }
+
+    @Test
+    public void example2() {
+        int[] answers = {10, 10, 10};
+        int expected = 11;
+        Assertions.assertEquals(expected, solution781.numRabbits(answers));
+    }
+
+    // 补充用例
+    @Test
+    public void example3() {
+        // https://leetcode.cn/submissions/detail/396407981/
+        int[] answers = {0, 0, 1, 1, 1};
+        int expected = 6;
+        Assertions.assertEquals(expected, solution781.numRabbits(answers));
+    }
+
+    @Test
+    public void example4() {
+        // https://leetcode.cn/submissions/detail/396407870/
+        int[] answers = {1, 0, 1, 0, 0};
+        int expected = 5;
+        Assertions.assertEquals(expected, solution781.numRabbits(answers));
+    }
+}
diff --git a/leetcode-12/src/main/java/Solution1121.java b/leetcode-12/src/main/java/Solution1121.java
@@ -0,0 +1,32 @@
+public class Solution1121 {
+    public boolean canDivideIntoSubsequences(int[] nums, int k) {
+        if (k == 1) {
+            return true;
+        }
+        int max = 0;
+        int cnt = 0;
+        int pre = -1;
+        for (int num : nums) {
+            if (num != pre) {
+                cnt = 1;
+            } else {
+                cnt++;
+            }
+            max = Math.max(max, cnt);
+            pre = num;
+        }
+        return max * k <= nums.length;
+    }
+}
+/*
+$1121. 将数组分成几个递增序列
+https://leetcode.cn/problems/divide-array-into-increasing-sequences/
+
+给你一个 非递减 的正整数数组 nums 和整数 K，判断该数组是否可以被分成一个或几个 长度至少 为 K 的 不相交的递增子序列。
+提示：
+1 <= nums.length <= 10^5
+1 <= K <= nums.length
+1 <= nums[i] <= 10^5
+
+贪心，设最大频次为 c，c * k 需小于等于 n
+ */
diff --git a/leetcode-12/src/test/java/Solution1121Tests.java b/leetcode-12/src/test/java/Solution1121Tests.java
@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1121Tests {
+    private final Solution1121 solution1121 = new Solution1121();
+
+    @Test
+    public void example1() {
+        int[] nums = {1, 2, 2, 3, 3, 4, 4};
+        int k = 3;
+        Assertions.assertTrue(solution1121.canDivideIntoSubsequences(nums, k));
+    }
+
+    @Test
+    public void example2() {
+        int[] nums = {5, 6, 6, 7, 8};
+        int k = 3;
+        Assertions.assertFalse(solution1121.canDivideIntoSubsequences(nums, k));
+    }
+}
diff --git a/leetcode-20/src/main/java/Solution1933.java b/leetcode-20/src/main/java/Solution1933.java
diff --git a/leetcode-20/src/test/java/Solution1933Tests.java b/leetcode-20/src/test/java/Solution1933Tests.java
