diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md b/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md index d3255436fb79c..073d0a88e91b7 100644 --- a/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md @@ -122,32 +122,348 @@ tags: -### 方法一 +### 方法一：字典树 + DFS + +我们可以使用字典树来存储文件夹的结构，字典树的每个节点数据如下： + +- `children`：一个字典，键为子文件夹的名称，值为对应的子节点。 +- `deleted`：一个布尔值，表示该节点是否被标记为待删除。 + +我们将所有路径插入到字典树中，然后使用 DFS 遍历字典树，构建每个子树的字符串表示。对于每个子树，如果它的字符串表示已经存在于一个全局字典中，则将该节点和全局字典中的对应节点都标记为待删除。最后，再次使用 DFS 遍历字典树，将未被标记的节点的路径添加到结果列表中。 #### Python3 ```python - +class Trie: + def __init__(self): + self.children: Dict[str, "Trie"] = defaultdict(Trie) + self.deleted: bool = False + + +class Solution: + def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]: + root = Trie() + for path in paths: + cur = root + for name in path: + if cur.children[name] is None: + cur.children[name] = Trie() + cur = cur.children[name] + + g: Dict[str, Trie] = {} + + def dfs(node: Trie) -> str: + if not node.children: + return "" + subs: List[str] = [] + for name, child in node.children.items(): + subs.append(f"{name}({dfs(child)})") + s = "".join(sorted(subs)) + if s in g: + node.deleted = g[s].deleted = True + else: + g[s] = node + return s + + def dfs2(node: Trie) -> None: + if node.deleted: + return + if path: + ans.append(path[:]) + for name, child in node.children.items(): + path.append(name) + dfs2(child) + path.pop() + + dfs(root) + ans: List[List[str]] = [] + path: List[str] = [] + dfs2(root) + return ans ``` #### Java ```java - +class Trie { + Map children; + boolean deleted; + + public Trie() { + children = new HashMap<>(); + deleted = false; + } +} + +class Solution { + public List> deleteDuplicateFolder(List> paths) { + Trie root = new Trie(); + for (List path : paths) { + Trie cur = root; + for (String name : path) { + if (!cur.children.containsKey(name)) { + cur.children.put(name, new Trie()); + } + cur = cur.children.get(name); + } + } + + Map g = new HashMap<>(); + + var dfs = new Function() { + @Override + public String apply(Trie node) { + if (node.children.isEmpty()) { + return ""; + } + List subs = new ArrayList<>(); + for (var entry : node.children.entrySet()) { + subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")"); + } + Collections.sort(subs); + String s = String.join("", subs); + if (g.containsKey(s)) { + node.deleted = true; + g.get(s).deleted = true; + } else { + g.put(s, node); + } + return s; + } + }; + + dfs.apply(root); + + List> ans = new ArrayList<>(); + List path = new ArrayList<>(); + + var dfs2 = new Function() { + @Override + public Void apply(Trie node) { + if (node.deleted) { + return null; + } + if (!path.isEmpty()) { + ans.add(new ArrayList<>(path)); + } + for (Map.Entry entry : node.children.entrySet()) { + path.add(entry.getKey()); + apply(entry.getValue()); + path.remove(path.size() - 1); + } + return null; + } + }; + + dfs2.apply(root); + + return ans; + } +} ``` #### C++ ```cpp - +class Trie { +public: + unordered_map children; + bool deleted = false; +}; + +class Solution { +public: + vector> deleteDuplicateFolder(vector>& paths) { + Trie* root = new Trie(); + + for (auto& path : paths) { + Trie* cur = root; + for (auto& name : path) { + if (cur->children.find(name) == cur->children.end()) { + cur->children[name] = new Trie(); + } + cur = cur->children[name]; + } + } + + unordered_map g; + + auto dfs = [&](this auto&& dfs, Trie* node) -> string { + if (node->children.empty()) return ""; + + vector subs; + for (auto& child : node->children) { + subs.push_back(child.first + "(" + dfs(child.second) + ")"); + } + sort(subs.begin(), subs.end()); + string s = ""; + for (auto& sub : subs) s += sub; + + if (g.contains(s)) { + node->deleted = true; + g[s]->deleted = true; + } else { + g[s] = node; + } + return s; + }; + + dfs(root); + + vector> ans; + vector path; + + auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void { + if (node->deleted) return; + if (!path.empty()) { + ans.push_back(path); + } + for (auto& child : node->children) { + path.push_back(child.first); + dfs2(child.second); + path.pop_back(); + } + }; + + dfs2(root); + + return ans; + } +}; ``` #### Go ```go +type Trie struct { + children map[string]*Trie + deleted bool +} + +func NewTrie() *Trie { + return &Trie{ + children: make(map[string]*Trie), + } +} + +func deleteDuplicateFolder(paths [][]string) (ans [][]string) { + root := NewTrie() + for _, path := range paths { + cur := root + for _, name := range path { + if _, exists := cur.children[name]; !exists { + cur.children[name] = NewTrie() + } + cur = cur.children[name] + } + } + + g := make(map[string]*Trie) + + var dfs func(*Trie) string + dfs = func(node *Trie) string { + if len(node.children) == 0 { + return "" + } + var subs []string + for name, child := range node.children { + subs = append(subs, name+"("+dfs(child)+")") + } + sort.Strings(subs) + s := strings.Join(subs, "") + if existingNode, exists := g[s]; exists { + node.deleted = true + existingNode.deleted = true + } else { + g[s] = node + } + return s + } + + var dfs2 func(*Trie, []string) + dfs2 = func(node *Trie, path []string) { + if node.deleted { + return + } + if len(path) > 0 { + ans = append(ans, append([]string{}, path...)) + } + for name, child := range node.children { + dfs2(child, append(path, name)) + } + } + + dfs(root) + dfs2(root, []string{}) + return ans +} +``` +#### TypeScript + +```ts +function deleteDuplicateFolder(paths: string[][]): string[][] { + class Trie { + children: { [key: string]: Trie } = {}; + deleted: boolean = false; + } + + const root = new Trie(); + + for (const path of paths) { + let cur = root; + for (const name of path) { + if (!cur.children[name]) { + cur.children[name] = new Trie(); + } + cur = cur.children[name]; + } + } + + const g: { [key: string]: Trie } = {}; + + const dfs = (node: Trie): string => { + if (Object.keys(node.children).length === 0) return ''; + + const subs: string[] = []; + for (const [name, child] of Object.entries(node.children)) { + subs.push(`${name}(${dfs(child)})`); + } + subs.sort(); + const s = subs.join(''); + + if (g[s]) { + node.deleted = true; + g[s].deleted = true; + } else { + g[s] = node; + } + return s; + }; + + dfs(root); + + const ans: string[][] = []; + const path: string[] = []; + + const dfs2 = (node: Trie): void => { + if (node.deleted) return; + if (path.length > 0) { + ans.push([...path]); + } + for (const [name, child] of Object.entries(node.children)) { + path.push(name); + dfs2(child); + path.pop(); + } + }; + + dfs2(root); + + return ans; +} ``` diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md b/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md index 01fa7d10a03c7..46b0bef223ac5 100644 --- a/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md @@ -68,7 +68,7 @@ folder named "b". 
 Input: paths = [["a"],["c"],["a","b"],["c","b"],["a","b","x"],["a","b","x","y"],["w"],["w","y"]]
 Output: [["c"],["c","b"],["a"],["a","b"]]
-Explanation: The file structure is as shown. 
+Explanation: The file structure is as shown.
 Folders "/a/b/x" and "/w" (and their subfolders) are marked for deletion because they both contain an empty folder named "y".
 Note that folders "/a" and "/c" are identical after the deletion, but they are not deleted because they were not marked beforehand.
@@ -101,32 +101,348 @@ Note that the returned array can be in a different order as the order does not m -### Solution 1 +### Solution 1: Trie + DFS + +We can use a trie to store the folder structure, where each node in the trie contains the following data: + +- `children`: A dictionary where the key is the name of the subfolder and the value is the corresponding child node. +- `deleted`: A boolean value indicating whether the node is marked for deletion. + +We insert all paths into the trie, then use DFS to traverse the trie and build a string representation for each subtree. For each subtree, if its string representation already exists in a global dictionary, we mark both the current node and the corresponding node in the global dictionary for deletion. Finally, we use DFS again to traverse the trie and add the paths of unmarked nodes to the result list. #### Python3 ```python - +class Trie: + def __init__(self): + self.children: Dict[str, "Trie"] = defaultdict(Trie) + self.deleted: bool = False + + +class Solution: + def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]: + root = Trie() + for path in paths: + cur = root + for name in path: + if cur.children[name] is None: + cur.children[name] = Trie() + cur = cur.children[name] + + g: Dict[str, Trie] = {} + + def dfs(node: Trie) -> str: + if not node.children: + return "" + subs: List[str] = [] + for name, child in node.children.items(): + subs.append(f"{name}({dfs(child)})") + s = "".join(sorted(subs)) + if s in g: + node.deleted = g[s].deleted = True + else: + g[s] = node + return s + + def dfs2(node: Trie) -> None: + if node.deleted: + return + if path: + ans.append(path[:]) + for name, child in node.children.items(): + path.append(name) + dfs2(child) + path.pop() + + dfs(root) + ans: List[List[str]] = [] + path: List[str] = [] + dfs2(root) + return ans ``` #### Java ```java - +class Trie { + Map children; + boolean deleted; + + public Trie() { + children = new HashMap<>(); + deleted = false; + } +} + +class Solution { + public List> deleteDuplicateFolder(List> paths) { + Trie root = new Trie(); + for (List path : paths) { + Trie cur = root; + for (String name : path) { + if (!cur.children.containsKey(name)) { + cur.children.put(name, new Trie()); + } + cur = cur.children.get(name); + } + } + + Map g = new HashMap<>(); + + var dfs = new Function() { + @Override + public String apply(Trie node) { + if (node.children.isEmpty()) { + return ""; + } + List subs = new ArrayList<>(); + for (var entry : node.children.entrySet()) { + subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")"); + } + Collections.sort(subs); + String s = String.join("", subs); + if (g.containsKey(s)) { + node.deleted = true; + g.get(s).deleted = true; + } else { + g.put(s, node); + } + return s; + } + }; + + dfs.apply(root); + + List> ans = new ArrayList<>(); + List path = new ArrayList<>(); + + var dfs2 = new Function() { + @Override + public Void apply(Trie node) { + if (node.deleted) { + return null; + } + if (!path.isEmpty()) { + ans.add(new ArrayList<>(path)); + } + for (Map.Entry entry : node.children.entrySet()) { + path.add(entry.getKey()); + apply(entry.getValue()); + path.remove(path.size() - 1); + } + return null; + } + }; + + dfs2.apply(root); + + return ans; + } +} ``` #### C++ ```cpp - +class Trie { +public: + unordered_map children; + bool deleted = false; +}; + +class Solution { +public: + vector> deleteDuplicateFolder(vector>& paths) { + Trie* root = new Trie(); + + for (auto& path : paths) { + Trie* cur = root; + for (auto& name : path) { + if (cur->children.find(name) == cur->children.end()) { + cur->children[name] = new Trie(); + } + cur = cur->children[name]; + } + } + + unordered_map g; + + auto dfs = [&](this auto&& dfs, Trie* node) -> string { + if (node->children.empty()) return ""; + + vector subs; + for (auto& child : node->children) { + subs.push_back(child.first + "(" + dfs(child.second) + ")"); + } + sort(subs.begin(), subs.end()); + string s = ""; + for (auto& sub : subs) s += sub; + + if (g.contains(s)) { + node->deleted = true; + g[s]->deleted = true; + } else { + g[s] = node; + } + return s; + }; + + dfs(root); + + vector> ans; + vector path; + + auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void { + if (node->deleted) return; + if (!path.empty()) { + ans.push_back(path); + } + for (auto& child : node->children) { + path.push_back(child.first); + dfs2(child.second); + path.pop_back(); + } + }; + + dfs2(root); + + return ans; + } +}; ``` #### Go ```go +type Trie struct { + children map[string]*Trie + deleted bool +} + +func NewTrie() *Trie { + return &Trie{ + children: make(map[string]*Trie), + } +} + +func deleteDuplicateFolder(paths [][]string) (ans [][]string) { + root := NewTrie() + for _, path := range paths { + cur := root + for _, name := range path { + if _, exists := cur.children[name]; !exists { + cur.children[name] = NewTrie() + } + cur = cur.children[name] + } + } + + g := make(map[string]*Trie) + + var dfs func(*Trie) string + dfs = func(node *Trie) string { + if len(node.children) == 0 { + return "" + } + var subs []string + for name, child := range node.children { + subs = append(subs, name+"("+dfs(child)+")") + } + sort.Strings(subs) + s := strings.Join(subs, "") + if existingNode, exists := g[s]; exists { + node.deleted = true + existingNode.deleted = true + } else { + g[s] = node + } + return s + } + + var dfs2 func(*Trie, []string) + dfs2 = func(node *Trie, path []string) { + if node.deleted { + return + } + if len(path) > 0 { + ans = append(ans, append([]string{}, path...)) + } + for name, child := range node.children { + dfs2(child, append(path, name)) + } + } + + dfs(root) + dfs2(root, []string{}) + return ans +} +``` +#### TypeScript + +```ts +function deleteDuplicateFolder(paths: string[][]): string[][] { + class Trie { + children: { [key: string]: Trie } = {}; + deleted: boolean = false; + } + + const root = new Trie(); + + for (const path of paths) { + let cur = root; + for (const name of path) { + if (!cur.children[name]) { + cur.children[name] = new Trie(); + } + cur = cur.children[name]; + } + } + + const g: { [key: string]: Trie } = {}; + + const dfs = (node: Trie): string => { + if (Object.keys(node.children).length === 0) return ''; + + const subs: string[] = []; + for (const [name, child] of Object.entries(node.children)) { + subs.push(`${name}(${dfs(child)})`); + } + subs.sort(); + const s = subs.join(''); + + if (g[s]) { + node.deleted = true; + g[s].deleted = true; + } else { + g[s] = node; + } + return s; + }; + + dfs(root); + + const ans: string[][] = []; + const path: string[] = []; + + const dfs2 = (node: Trie): void => { + if (node.deleted) return; + if (path.length > 0) { + ans.push([...path]); + } + for (const [name, child] of Object.entries(node.children)) { + path.push(name); + dfs2(child); + path.pop(); + } + }; + + dfs2(root); + + return ans; +} ``` diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp new file mode 100644 index 0000000000000..3f7b140bc9353 --- /dev/null +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp @@ -0,0 +1,65 @@ +class Trie { +public: + unordered_map children; + bool deleted = false; +}; + +class Solution { +public: + vector> deleteDuplicateFolder(vector>& paths) { + Trie* root = new Trie(); + + for (auto& path : paths) { + Trie* cur = root; + for (auto& name : path) { + if (cur->children.find(name) == cur->children.end()) { + cur->children[name] = new Trie(); + } + cur = cur->children[name]; + } + } + + unordered_map g; + + auto dfs = [&](this auto&& dfs, Trie* node) -> string { + if (node->children.empty()) return ""; + + vector subs; + for (auto& child : node->children) { + subs.push_back(child.first + "(" + dfs(child.second) + ")"); + } + sort(subs.begin(), subs.end()); + string s = ""; + for (auto& sub : subs) s += sub; + + if (g.contains(s)) { + node->deleted = true; + g[s]->deleted = true; + } else { + g[s] = node; + } + return s; + }; + + dfs(root); + + vector> ans; + vector path; + + auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void { + if (node->deleted) return; + if (!path.empty()) { + ans.push_back(path); + } + for (auto& child : node->children) { + path.push_back(child.first); + dfs2(child.second); + path.pop_back(); + } + }; + + dfs2(root); + + return ans; + } +}; diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go new file mode 100644 index 0000000000000..2b61f3796a413 --- /dev/null +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go @@ -0,0 +1,62 @@ +type Trie struct { + children map[string]*Trie + deleted bool +} + +func NewTrie() *Trie { + return &Trie{ + children: make(map[string]*Trie), + } +} + +func deleteDuplicateFolder(paths [][]string) (ans [][]string) { + root := NewTrie() + for _, path := range paths { + cur := root + for _, name := range path { + if _, exists := cur.children[name]; !exists { + cur.children[name] = NewTrie() + } + cur = cur.children[name] + } + } + + g := make(map[string]*Trie) + + var dfs func(*Trie) string + dfs = func(node *Trie) string { + if len(node.children) == 0 { + return "" + } + var subs []string + for name, child := range node.children { + subs = append(subs, name+"("+dfs(child)+")") + } + sort.Strings(subs) + s := strings.Join(subs, "") + if existingNode, exists := g[s]; exists { + node.deleted = true + existingNode.deleted = true + } else { + g[s] = node + } + return s + } + + var dfs2 func(*Trie, []string) + dfs2 = func(node *Trie, path []string) { + if node.deleted { + return + } + if len(path) > 0 { + ans = append(ans, append([]string{}, path...)) + } + for name, child := range node.children { + dfs2(child, append(path, name)) + } + } + + dfs(root) + dfs2(root, []string{}) + return ans +} diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java new file mode 100644 index 0000000000000..cd5912d34b40c --- /dev/null +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java @@ -0,0 +1,75 @@ +class Trie { + Map children; + boolean deleted; + + public Trie() { + children = new HashMap<>(); + deleted = false; + } +} + +class Solution { + public List> deleteDuplicateFolder(List> paths) { + Trie root = new Trie(); + for (List path : paths) { + Trie cur = root; + for (String name : path) { + if (!cur.children.containsKey(name)) { + cur.children.put(name, new Trie()); + } + cur = cur.children.get(name); + } + } + + Map g = new HashMap<>(); + + var dfs = new Function() { + @Override + public String apply(Trie node) { + if (node.children.isEmpty()) { + return ""; + } + List subs = new ArrayList<>(); + for (var entry : node.children.entrySet()) { + subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")"); + } + Collections.sort(subs); + String s = String.join("", subs); + if (g.containsKey(s)) { + node.deleted = true; + g.get(s).deleted = true; + } else { + g.put(s, node); + } + return s; + } + }; + + dfs.apply(root); + + List> ans = new ArrayList<>(); + List path = new ArrayList<>(); + + var dfs2 = new Function() { + @Override + public Void apply(Trie node) { + if (node.deleted) { + return null; + } + if (!path.isEmpty()) { + ans.add(new ArrayList<>(path)); + } + for (Map.Entry entry : node.children.entrySet()) { + path.add(entry.getKey()); + apply(entry.getValue()); + path.remove(path.size() - 1); + } + return null; + } + }; + + dfs2.apply(root); + + return ans; + } +} diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py new file mode 100644 index 0000000000000..9031f263762d1 --- /dev/null +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py @@ -0,0 +1,46 @@ +class Trie: + def __init__(self): + self.children: Dict[str, "Trie"] = defaultdict(Trie) + self.deleted: bool = False + + +class Solution: + def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]: + root = Trie() + for path in paths: + cur = root + for name in path: + if cur.children[name] is None: + cur.children[name] = Trie() + cur = cur.children[name] + + g: Dict[str, Trie] = {} + + def dfs(node: Trie) -> str: + if not node.children: + return "" + subs: List[str] = [] + for name, child in node.children.items(): + subs.append(f"{name}({dfs(child)})") + s = "".join(sorted(subs)) + if s in g: + node.deleted = g[s].deleted = True + else: + g[s] = node + return s + + def dfs2(node: Trie) -> None: + if node.deleted: + return + if path: + ans.append(path[:]) + for name, child in node.children.items(): + path.append(name) + dfs2(child) + path.pop() + + dfs(root) + ans: List[List[str]] = [] + path: List[str] = [] + dfs2(root) + return ans diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts new file mode 100644 index 0000000000000..10096fe3014d4 --- /dev/null +++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts @@ -0,0 +1,60 @@ +function deleteDuplicateFolder(paths: string[][]): string[][] { + class Trie { + children: { [key: string]: Trie } = {}; + deleted: boolean = false; + } + + const root = new Trie(); + + for (const path of paths) { + let cur = root; + for (const name of path) { + if (!cur.children[name]) { + cur.children[name] = new Trie(); + } + cur = cur.children[name]; + } + } + + const g: { [key: string]: Trie } = {}; + + const dfs = (node: Trie): string => { + if (Object.keys(node.children).length === 0) return ''; + + const subs: string[] = []; + for (const [name, child] of Object.entries(node.children)) { + subs.push(`${name}(${dfs(child)})`); + } + subs.sort(); + const s = subs.join(''); + + if (g[s]) { + node.deleted = true; + g[s].deleted = true; + } else { + g[s] = node; + } + return s; + }; + + dfs(root); + + const ans: string[][] = []; + const path: string[] = []; + + const dfs2 = (node: Trie): void => { + if (node.deleted) return; + if (path.length > 0) { + ans.push([...path]); + } + for (const [name, child] of Object.entries(node.children)) { + path.push(name); + dfs2(child); + path.pop(); + } + }; + + dfs2(root); + + return ans; +} diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/README.md b/solution/3600-3699/3618.Split Array by Prime Indices/README.md index 0ef7d7b1daf79..2f8a57f998a13 100644 --- a/solution/3600-3699/3618.Split Array by Prime Indices/README.md +++ b/solution/3600-3699/3618.Split Array by Prime Indices/README.md @@ -80,32 +80,153 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3618.Sp -### 方法一 +### 方法一：埃氏筛 + 模拟 + +我们可以用埃氏筛法预处理出 $[0, 10^5]$ 范围内的所有质数。然后遍历数组 $ +\textit{nums}$，对于 $\textit{nums}[i]$，如果 $i$ 是质数，则将 $\textit{nums}[i]$ 加到答案中，否则将 $-\textit{nums}[i]$ 加到答案中。最后返回答案的绝对值。 + +忽略预处理的时间和空间，时间复杂度 $O(n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度，空间复杂度 $O(1)$。 #### Python3 ```python - +m = 10**5 + 10 +primes = [True] * m +primes[0] = primes[1] = False +for i in range(2, m): + if primes[i]: + for j in range(i + i, m, i): + primes[j] = False + + +class Solution: + def splitArray(self, nums: List[int]) -> int: + return abs(sum(x if primes[i] else -x for i, x in enumerate(nums))) ``` #### Java ```java - +class Solution { + private static final int M = 100000 + 10; + private static boolean[] primes = new boolean[M]; + + static { + for (int i = 0; i < M; i++) { + primes[i] = true; + } + primes[0] = primes[1] = false; + + for (int i = 2; i < M; i++) { + if (primes[i]) { + for (int j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } + } + + public long splitArray(int[] nums) { + long ans = 0; + for (int i = 0; i < nums.length; ++i) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return Math.abs(ans); + } +} ``` #### C++ ```cpp - +const int M = 1e5 + 10; +bool primes[M]; +auto init = [] { + memset(primes, true, sizeof(primes)); + primes[0] = primes[1] = false; + for (int i = 2; i < M; ++i) { + if (primes[i]) { + for (int j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } + return 0; +}(); + +class Solution { +public: + long long splitArray(vector& nums) { + long long ans = 0; + for (int i = 0; i < nums.size(); ++i) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return abs(ans); + } +}; ``` #### Go ```go +const M = 100000 + 10 + +var primes [M]bool + +func init() { + for i := 0; i < M; i++ { + primes[i] = true + } + primes[0], primes[1] = false, false + + for i := 2; i < M; i++ { + if primes[i] { + for j := i + i; j < M; j += i { + primes[j] = false + } + } + } +} + +func splitArray(nums []int) (ans int64) { + for i, num := range nums { + if primes[i] { + ans += int64(num) + } else { + ans -= int64(num) + } + } + return max(ans, -ans) +} +``` +#### TypeScript + +```ts +const M = 100000 + 10; +const primes: boolean[] = Array(M).fill(true); + +const init = (() => { + primes[0] = primes[1] = false; + + for (let i = 2; i < M; i++) { + if (primes[i]) { + for (let j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } +})(); + +function splitArray(nums: number[]): number { + let ans = 0; + for (let i = 0; i < nums.length; i++) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return Math.abs(ans); +} ``` diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/README_EN.md b/solution/3600-3699/3618.Split Array by Prime Indices/README_EN.md index fb6bdd1ef7c47..ed7c083b3b062 100644 --- a/solution/3600-3699/3618.Split Array by Prime Indices/README_EN.md +++ b/solution/3600-3699/3618.Split Array by Prime Indices/README_EN.md @@ -78,32 +78,152 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3618.Sp -### Solution 1 +### Solution 1: Sieve of Eratosthenes + Simulation + +We can use the Sieve of Eratosthenes to preprocess all prime numbers in the range $[0, 10^5]$. Then we iterate through the array $\textit{nums}$. For $\textit{nums}[i]$, if $i$ is a prime number, we add $\textit{nums}[i]$ to the answer; otherwise, we add $-\textit{nums}[i]$ to the answer. Finally, we return the absolute value of the answer. + +Ignoring the preprocessing time and space, the time complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$, and the space complexity is $O(1)$. #### Python3 ```python - +m = 10**5 + 10 +primes = [True] * m +primes[0] = primes[1] = False +for i in range(2, m): + if primes[i]: + for j in range(i + i, m, i): + primes[j] = False + + +class Solution: + def splitArray(self, nums: List[int]) -> int: + return abs(sum(x if primes[i] else -x for i, x in enumerate(nums))) ``` #### Java ```java - +class Solution { + private static final int M = 100000 + 10; + private static boolean[] primes = new boolean[M]; + + static { + for (int i = 0; i < M; i++) { + primes[i] = true; + } + primes[0] = primes[1] = false; + + for (int i = 2; i < M; i++) { + if (primes[i]) { + for (int j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } + } + + public long splitArray(int[] nums) { + long ans = 0; + for (int i = 0; i < nums.length; ++i) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return Math.abs(ans); + } +} ``` #### C++ ```cpp - +const int M = 1e5 + 10; +bool primes[M]; +auto init = [] { + memset(primes, true, sizeof(primes)); + primes[0] = primes[1] = false; + for (int i = 2; i < M; ++i) { + if (primes[i]) { + for (int j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } + return 0; +}(); + +class Solution { +public: + long long splitArray(vector& nums) { + long long ans = 0; + for (int i = 0; i < nums.size(); ++i) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return abs(ans); + } +}; ``` #### Go ```go +const M = 100000 + 10 + +var primes [M]bool + +func init() { + for i := 0; i < M; i++ { + primes[i] = true + } + primes[0], primes[1] = false, false + + for i := 2; i < M; i++ { + if primes[i] { + for j := i + i; j < M; j += i { + primes[j] = false + } + } + } +} + +func splitArray(nums []int) (ans int64) { + for i, num := range nums { + if primes[i] { + ans += int64(num) + } else { + ans -= int64(num) + } + } + return max(ans, -ans) +} +``` +#### TypeScript + +```ts +const M = 100000 + 10; +const primes: boolean[] = Array(M).fill(true); + +const init = (() => { + primes[0] = primes[1] = false; + + for (let i = 2; i < M; i++) { + if (primes[i]) { + for (let j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } +})(); + +function splitArray(nums: number[]): number { + let ans = 0; + for (let i = 0; i < nums.length; i++) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return Math.abs(ans); +} ``` diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/Solution.cpp b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.cpp new file mode 100644 index 0000000000000..896e6027a692d --- /dev/null +++ b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.cpp @@ -0,0 +1,25 @@ +const int M = 1e5 + 10; +bool primes[M]; +auto init = [] { + memset(primes, true, sizeof(primes)); + primes[0] = primes[1] = false; + for (int i = 2; i < M; ++i) { + if (primes[i]) { + for (int j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } + return 0; +}(); + +class Solution { +public: + long long splitArray(vector& nums) { + long long ans = 0; + for (int i = 0; i < nums.size(); ++i) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return abs(ans); + } +}; \ No newline at end of file diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/Solution.go b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.go new file mode 100644 index 0000000000000..21930686a3115 --- /dev/null +++ b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.go @@ -0,0 +1,29 @@ +const M = 100000 + 10 + +var primes [M]bool + +func init() { + for i := 0; i < M; i++ { + primes[i] = true + } + primes[0], primes[1] = false, false + + for i := 2; i < M; i++ { + if primes[i] { + for j := i + i; j < M; j += i { + primes[j] = false + } + } + } +} + +func splitArray(nums []int) (ans int64) { + for i, num := range nums { + if primes[i] { + ans += int64(num) + } else { + ans -= int64(num) + } + } + return max(ans, -ans) +} diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/Solution.java b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.java new file mode 100644 index 0000000000000..2226459f0a7e9 --- /dev/null +++ b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.java @@ -0,0 +1,27 @@ +class Solution { + private static final int M = 100000 + 10; + private static boolean[] primes = new boolean[M]; + + static { + for (int i = 0; i < M; i++) { + primes[i] = true; + } + primes[0] = primes[1] = false; + + for (int i = 2; i < M; i++) { + if (primes[i]) { + for (int j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } + } + + public long splitArray(int[] nums) { + long ans = 0; + for (int i = 0; i < nums.length; ++i) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return Math.abs(ans); + } +} diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/Solution.py b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.py new file mode 100644 index 0000000000000..963f5741ecced --- /dev/null +++ b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.py @@ -0,0 +1,12 @@ +m = 10**5 + 10 +primes = [True] * m +primes[0] = primes[1] = False +for i in range(2, m): + if primes[i]: + for j in range(i + i, m, i): + primes[j] = False + + +class Solution: + def splitArray(self, nums: List[int]) -> int: + return abs(sum(x if primes[i] else -x for i, x in enumerate(nums))) diff --git a/solution/3600-3699/3618.Split Array by Prime Indices/Solution.ts b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.ts new file mode 100644 index 0000000000000..0c8838482c956 --- /dev/null +++ b/solution/3600-3699/3618.Split Array by Prime Indices/Solution.ts @@ -0,0 +1,22 @@ +const M = 100000 + 10; +const primes: boolean[] = Array(M).fill(true); + +const init = (() => { + primes[0] = primes[1] = false; + + for (let i = 2; i < M; i++) { + if (primes[i]) { + for (let j = i + i; j < M; j += i) { + primes[j] = false; + } + } + } +})(); + +function splitArray(nums: number[]): number { + let ans = 0; + for (let i = 0; i < nums.length; i++) { + ans += primes[i] ? nums[i] : -nums[i]; + } + return Math.abs(ans); +} diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README.md b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README.md index ad3505a76ed46..ded52895b260f 100644 --- a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README.md +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README.md @@ -65,32 +65,172 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3619.Co -### 方法一 +### 方法一：DFS + +我们定义一个函数 $\textit{dfs}(i, j)$，它从位置 $(i, j)$ 开始进行 DFS 遍历，并且返回该岛屿的总价值。我们将当前位置的值加入总价值，然后将该位置标记为已访问（例如，将其值设为 0）。接着，我们递归地访问四个方向（上、下、左、右）的相邻位置，如果相邻位置的值大于 0，则继续进行 DFS，并将其值加入总价值。最后，我们返回总价值。 + +在主函数中，我们遍历整个网格，对于每个未访问的位置 $(i, j)$，如果其值大于 0，则调用 $\textit{dfs}(i, j)$ 来计算该岛屿的总价值。如果总价值可以被 $k$ 整除，则将答案加一。 + +时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是网格的行数和列数。 #### Python3 ```python - +class Solution: + def countIslands(self, grid: List[List[int]], k: int) -> int: + def dfs(i: int, j: int) -> int: + s = grid[i][j] + grid[i][j] = 0 + for a, b in pairwise(dirs): + x, y = i + a, j + b + if 0 <= x < m and 0 <= y < n and grid[x][y]: + s += dfs(x, y) + return s + + m, n = len(grid), len(grid[0]) + dirs = (-1, 0, 1, 0, -1) + ans = 0 + for i in range(m): + for j in range(n): + if grid[i][j] and dfs(i, j) % k == 0: + ans += 1 + return ans ``` #### Java ```java - +class Solution { + private int m; + private int n; + private int[][] grid; + private final int[] dirs = {-1, 0, 1, 0, -1}; + + public int countIslands(int[][] grid, int k) { + m = grid.length; + n = grid[0].length; + this.grid = grid; + int ans = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] > 0 && dfs(i, j) % k == 0) { + ++ans; + } + } + } + return ans; + } + + private long dfs(int i, int j) { + long s = grid[i][j]; + grid[i][j] = 0; + for (int d = 0; d < 4; ++d) { + int x = i + dirs[d], y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) { + s += dfs(x, y); + } + } + return s; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int countIslands(vector>& grid, int k) { + int m = grid.size(), n = grid[0].size(); + vector dirs = {-1, 0, 1, 0, -1}; + + auto dfs = [&](this auto&& dfs, int i, int j) -> long long { + long long s = grid[i][j]; + grid[i][j] = 0; + for (int d = 0; d < 4; ++d) { + int x = i + dirs[d], y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y]) { + s += dfs(x, y); + } + } + return s; + }; + + int ans = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] && dfs(i, j) % k == 0) { + ++ans; + } + } + } + return ans; + } +}; ``` #### Go ```go +func countIslands(grid [][]int, k int) (ans int) { + m, n := len(grid), len(grid[0]) + dirs := []int{-1, 0, 1, 0, -1} + var dfs func(i, j int) int + dfs = func(i, j int) int { + s := grid[i][j] + grid[i][j] = 0 + for d := 0; d < 4; d++ { + x, y := i+dirs[d], j+dirs[d+1] + if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0 { + s += dfs(x, y) + } + } + return s + } + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] > 0 && dfs(i, j)%k == 0 { + ans++ + } + } + } + return +} +``` +#### TypeScript + +```ts +function countIslands(grid: number[][], k: number): number { + const m = grid.length, + n = grid[0].length; + const dirs = [-1, 0, 1, 0, -1]; + const dfs = (i: number, j: number): number => { + let s = grid[i][j]; + grid[i][j] = 0; + for (let d = 0; d < 4; d++) { + const x = i + dirs[d], + y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) { + s += dfs(x, y); + } + } + return s; + }; + + let ans = 0; + for (let i = 0; i < m; i++) { + for (let j = 0; j < n; j++) { + if (grid[i][j] > 0 && dfs(i, j) % k === 0) { + ans++; + } + } + } + + return ans; +} ``` diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README_EN.md b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README_EN.md index b47d245a99e1c..dee73c6315c7e 100644 --- a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README_EN.md +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/README_EN.md @@ -63,32 +63,172 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3619.Co -### Solution 1 +### Solution 1: DFS + +We define a function $\textit{dfs}(i, j)$, which performs DFS traversal starting from position $(i, j)$ and returns the total value of that island. We add the current position's value to the total value, then mark that position as visited (for example, by setting its value to 0). Next, we recursively visit the adjacent positions in four directions (up, down, left, right). If an adjacent position has a value greater than 0, we continue the DFS and add its value to the total value. Finally, we return the total value. + +In the main function, we traverse the entire grid. For each unvisited position $(i, j)$, if its value is greater than 0, we call $\textit{dfs}(i, j)$ to calculate the total value of that island. If the total value is divisible by $k$, we increment the answer by one. + +The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$, where $m$ and $n$ are the number of rows and columns of the grid, respectively. #### Python3 ```python - +class Solution: + def countIslands(self, grid: List[List[int]], k: int) -> int: + def dfs(i: int, j: int) -> int: + s = grid[i][j] + grid[i][j] = 0 + for a, b in pairwise(dirs): + x, y = i + a, j + b + if 0 <= x < m and 0 <= y < n and grid[x][y]: + s += dfs(x, y) + return s + + m, n = len(grid), len(grid[0]) + dirs = (-1, 0, 1, 0, -1) + ans = 0 + for i in range(m): + for j in range(n): + if grid[i][j] and dfs(i, j) % k == 0: + ans += 1 + return ans ``` #### Java ```java - +class Solution { + private int m; + private int n; + private int[][] grid; + private final int[] dirs = {-1, 0, 1, 0, -1}; + + public int countIslands(int[][] grid, int k) { + m = grid.length; + n = grid[0].length; + this.grid = grid; + int ans = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] > 0 && dfs(i, j) % k == 0) { + ++ans; + } + } + } + return ans; + } + + private long dfs(int i, int j) { + long s = grid[i][j]; + grid[i][j] = 0; + for (int d = 0; d < 4; ++d) { + int x = i + dirs[d], y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) { + s += dfs(x, y); + } + } + return s; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int countIslands(vector>& grid, int k) { + int m = grid.size(), n = grid[0].size(); + vector dirs = {-1, 0, 1, 0, -1}; + + auto dfs = [&](this auto&& dfs, int i, int j) -> long long { + long long s = grid[i][j]; + grid[i][j] = 0; + for (int d = 0; d < 4; ++d) { + int x = i + dirs[d], y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y]) { + s += dfs(x, y); + } + } + return s; + }; + + int ans = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] && dfs(i, j) % k == 0) { + ++ans; + } + } + } + return ans; + } +}; ``` #### Go ```go +func countIslands(grid [][]int, k int) (ans int) { + m, n := len(grid), len(grid[0]) + dirs := []int{-1, 0, 1, 0, -1} + var dfs func(i, j int) int + dfs = func(i, j int) int { + s := grid[i][j] + grid[i][j] = 0 + for d := 0; d < 4; d++ { + x, y := i+dirs[d], j+dirs[d+1] + if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0 { + s += dfs(x, y) + } + } + return s + } + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] > 0 && dfs(i, j)%k == 0 { + ans++ + } + } + } + return +} +``` +#### TypeScript + +```ts +function countIslands(grid: number[][], k: number): number { + const m = grid.length, + n = grid[0].length; + const dirs = [-1, 0, 1, 0, -1]; + const dfs = (i: number, j: number): number => { + let s = grid[i][j]; + grid[i][j] = 0; + for (let d = 0; d < 4; d++) { + const x = i + dirs[d], + y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) { + s += dfs(x, y); + } + } + return s; + }; + + let ans = 0; + for (let i = 0; i < m; i++) { + for (let j = 0; j < n; j++) { + if (grid[i][j] > 0 && dfs(i, j) % k === 0) { + ans++; + } + } + } + + return ans; +} ``` diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.cpp b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.cpp new file mode 100644 index 0000000000000..5ce322250145e --- /dev/null +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.cpp @@ -0,0 +1,29 @@ +class Solution { +public: + int countIslands(vector>& grid, int k) { + int m = grid.size(), n = grid[0].size(); + vector dirs = {-1, 0, 1, 0, -1}; + + auto dfs = [&](this auto&& dfs, int i, int j) -> long long { + long long s = grid[i][j]; + grid[i][j] = 0; + for (int d = 0; d < 4; ++d) { + int x = i + dirs[d], y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y]) { + s += dfs(x, y); + } + } + return s; + }; + + int ans = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] && dfs(i, j) % k == 0) { + ++ans; + } + } + } + return ans; + } +}; diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.go b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.go new file mode 100644 index 0000000000000..74fc51693d965 --- /dev/null +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.go @@ -0,0 +1,24 @@ +func countIslands(grid [][]int, k int) (ans int) { + m, n := len(grid), len(grid[0]) + dirs := []int{-1, 0, 1, 0, -1} + var dfs func(i, j int) int + dfs = func(i, j int) int { + s := grid[i][j] + grid[i][j] = 0 + for d := 0; d < 4; d++ { + x, y := i+dirs[d], j+dirs[d+1] + if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0 { + s += dfs(x, y) + } + } + return s + } + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] > 0 && dfs(i, j)%k == 0 { + ans++ + } + } + } + return +} diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.java b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.java new file mode 100644 index 0000000000000..901a053339e7f --- /dev/null +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.java @@ -0,0 +1,33 @@ +class Solution { + private int m; + private int n; + private int[][] grid; + private final int[] dirs = {-1, 0, 1, 0, -1}; + + public int countIslands(int[][] grid, int k) { + m = grid.length; + n = grid[0].length; + this.grid = grid; + int ans = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] > 0 && dfs(i, j) % k == 0) { + ++ans; + } + } + } + return ans; + } + + private long dfs(int i, int j) { + long s = grid[i][j]; + grid[i][j] = 0; + for (int d = 0; d < 4; ++d) { + int x = i + dirs[d], y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) { + s += dfs(x, y); + } + } + return s; + } +} \ No newline at end of file diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.py b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.py new file mode 100644 index 0000000000000..80dc273d4bc56 --- /dev/null +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.py @@ -0,0 +1,19 @@ +class Solution: + def countIslands(self, grid: List[List[int]], k: int) -> int: + def dfs(i: int, j: int) -> int: + s = grid[i][j] + grid[i][j] = 0 + for a, b in pairwise(dirs): + x, y = i + a, j + b + if 0 <= x < m and 0 <= y < n and grid[x][y]: + s += dfs(x, y) + return s + + m, n = len(grid), len(grid[0]) + dirs = (-1, 0, 1, 0, -1) + ans = 0 + for i in range(m): + for j in range(n): + if grid[i][j] and dfs(i, j) % k == 0: + ans += 1 + return ans diff --git a/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.ts b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.ts new file mode 100644 index 0000000000000..73bd758b5924f --- /dev/null +++ b/solution/3600-3699/3619.Count Islands With Total Value Divisible by K/Solution.ts @@ -0,0 +1,28 @@ +function countIslands(grid: number[][], k: number): number { + const m = grid.length, + n = grid[0].length; + const dirs = [-1, 0, 1, 0, -1]; + const dfs = (i: number, j: number): number => { + let s = grid[i][j]; + grid[i][j] = 0; + for (let d = 0; d < 4; d++) { + const x = i + dirs[d], + y = j + dirs[d + 1]; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) { + s += dfs(x, y); + } + } + return s; + }; + + let ans = 0; + for (let i = 0; i < m; i++) { + for (let j = 0; j < n; j++) { + if (grid[i][j] > 0 && dfs(i, j) % k === 0) { + ans++; + } + } + } + + return ans; +}