Merge pull request DaleStudy#154 from WhiteHyun/whitehyun/week9

[Hyun] Week 9 Solution Explanation

Author: WhiteHyun

clone-graph/WhiteHyun.swift

@@ -0,0 +1,41 @@
+//  
+//  133. Clone Graph
+//  https://leetcode.com/problems/clone-graph/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/28.
+//  
+
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var neighbors: [Node?]
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.neighbors = []
+ *     }
+ * }
+ */
+
+class Solution {
+  var cache: [Int: Node] = [:]
+
+  func cloneGraph(_ originalNode: Node?) -> Node? {
+    guard let originalNode
+    else {
+      return nil
+    }
+
+    guard cache[originalNode.val] == nil
+    else { return cache[originalNode.val]! }
+
+    let node = Node(originalNode.val)
+    cache[originalNode.val] = node
+
+
+    node.neighbors = originalNode.neighbors.map(cloneGraph)
+
+    return node
+  }
+}

course-schedule/WhiteHyun.swift

@@ -0,0 +1,43 @@
+//  
+//  207. Course Schedule
+//  https://leetcode.com/problems/course-schedule/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/30.
+//  
+
+class Solution {
+  func canFinish(_ numCourses: Int, _ prerequisites: [[Int]]) -> Bool {
+    var graph: [Int: [Int]] = [:]
+    var visited: [Int: Bool] = [:]
+
+    // 그래프 구성
+    for prereq in prerequisites {
+      let course = prereq[0]
+      let prerequisite = prereq[1]
+      graph[course, default: []].append(prerequisite)
+    }
+
+    func dfs(_ course: Int) -> Bool {
+      if visited[course] == true { return false }
+      if visited[course] == false { return true }
+
+      visited[course] = true
+
+      if let prerequisites = graph[course] {
+        for prereq in prerequisites {
+          if !dfs(prereq) { return false }
+        }
+      }
+
+      visited[course] = false
+      return true
+    }
+
+    for course in 0 ..< numCourses {
+      if !dfs(course) { return false }
+    }
+
+    return true
+  }
+}

design-add-and-search-words-data-structure/WhiteHyun.swift

@@ -0,0 +1,55 @@
+//
+//  211. Design Add and Search Words Data Structure
+//  https://leetcode.com/problems/design-add-and-search-words-data-structure/description/
+//  Dale-Study
+//
+//  Created by WhiteHyun on 2024/06/28.
+//
+
+private final class Node {
+  var children: [Character: Node]
+  var endOfWord: Bool
+
+  init(
+    children: [Character: Node] = [:],
+    endOfWord: Bool = false
+  ) {
+    self.children = children
+    self.endOfWord = endOfWord
+  }
+}
+
+final class WordDictionary {
+  private let root: Node
+
+  init() {
+    root = Node()
+  }
+
+  func addWord(_ word: String) {
+    var node = root
+    for character in word {
+      if node.children[character] == nil {
+        node.children[character] = Node()
+      }
+      node = node.children[character]!
+    }
+    node.endOfWord = true
+  }
+
+  func search(_ word: String) -> Bool {
+    let word = Array(word)
+    func dfs(index: Int, node: Node) -> Bool {
+      guard index < word.count else { return node.endOfWord }
+
+      let character = word[index]
+      if character == "." {
+        return node.children.values.contains { dfs(index: index + 1, node: $0) }
+      } else if let nextNode = node.children[character] {
+        return dfs(index: index + 1, node: nextNode)
+      }
+      return false
+    }
+    return dfs(index: 0, node: root)
+  }
+}

number-of-islands/WhiteHyun.swift

@@ -0,0 +1,48 @@
+//  
+//  200. Number of Islands
+//  https://leetcode.com/problems/number-of-islands/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/28.
+//  
+
+class Solution {
+  func numIslands(_ grid: [[Character]]) -> Int {
+    var visited: [[Bool]] = .init(
+      repeating: .init(repeating: false, count: grid[0].count),
+      count: grid.count
+    )
+    var islands = 0
+
+    for row in 0 ..< grid.count {
+      for col in 0 ..< grid[row].count where grid[row][col] == "1" && !visited[row][col] {
+        visited[row][col] = true
+        dfs(grid, &visited, row, col)
+        islands += 1
+      }
+    }
+
+    return islands
+  }
+
+  private func dfs(
+    _ grid: [[Character]],
+    _ visited: inout [[Bool]],
+    _ x: Int,
+    _ y: Int
+  ) {
+    for (dx, dy) in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
+      let nx = dx + x
+      let ny = dy + y
+      guard grid.indices ~= nx,
+            grid[x].indices ~= ny,
+            visited[nx][ny] == false,
+            grid[nx][ny] == "1"
+      else {
+        continue
+      }
+      visited[nx][ny] = true
+      dfs(grid, &visited, nx, ny)
+    }
+  }
+}

pacific-atlantic-water-flow/WhiteHyun.swift

@@ -0,0 +1,60 @@
+//  
+//  417. Pacific Atlantic Water Flow
+//  https://leetcode.com/problems/pacific-atlantic-water-flow/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/29.
+//  
+
+class Solution {
+  func pacificAtlantic(_ heights: [[Int]]) -> [[Int]] {
+    var result: [[Int]] = []
+    for i in heights.indices {
+      for j in heights[i].indices where isValid(i, j, heights) {
+        result.append([i, j])
+      }
+    }
+
+    return result
+  }
+
+  private func isValid(_ i: Int, _ j: Int, _ heights: [[Int]]) -> Bool {
+    var visited: [[Bool]] = .init(
+      repeating: .init(repeating: false, count: heights[i].count),
+      count: heights.count
+    )
+    visited[i][j] = true
+    var pacificOceanFlag = i == 0 || j == 0
+    var atlanticOceanFlag = i == heights.count - 1 || j == heights[i].count - 1
+
+    func dfs(_ x: Int, _ y: Int) {
+      if pacificOceanFlag, atlanticOceanFlag { return }
+      for (dx, dy) in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
+        let nx = x + dx
+        let ny = y + dy
+
+        guard heights.indices ~= nx,
+              heights[nx].indices ~= ny,
+              visited[nx][ny] == false,
+              heights[nx][ny] <= heights[x][y]
+        else {
+          continue
+        }
+
+        visited[nx][ny] = true
+        if nx == 0 || ny == 0 {
+          pacificOceanFlag = true
+        }
+        if nx == heights.endIndex - 1 || ny == heights[nx].endIndex - 1 {
+          atlanticOceanFlag = true
+        }
+
+        dfs(nx, ny)
+      }
+    }
+
+    dfs(i, j)
+
+    return pacificOceanFlag && atlanticOceanFlag
+  }
+}