Merge pull request #168 from WhiteHyun/whitehyun/week10

[Hyun] Week 10 Solution Explanation

Author: WhiteHyun

graph-valid-tree/WhiteHyun.swift

@@ -0,0 +1,42 @@
+//  
+//  261. Graph Valid Tree
+//  https://leetcode.com/problems/graph-valid-tree/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/07/06.
+//  
+
+final class Solution {
+  func validTree(_ n: Int, _ edges: [[Int]]) -> Bool {
+    guard edges.count == n - 1
+    else {
+      return false
+    }
+
+    var dictionary: [Int: [Int]] = [:]
+    var visited: Set<Int> = []
+
+    for edge in edges {
+      dictionary[edge[0], default: []].append(edge[1])
+      dictionary[edge[1], default: []].append(edge[0])
+    }
+
+    func dfs(parent: Int, node: Int) {
+      if visited.contains(node) {
+        return
+      }
+
+      visited.insert(node)
+
+      if let childNodes = dictionary[node] {
+        for childNode in childNodes where childNode != parent {
+          dfs(parent: node, node: childNode)
+        }
+      }
+    }
+
+    dfs(parent: -1, node: 0)
+
+    return visited.count == n
+  }
+}

house-robber-ii/WhiteHyun.swift

@@ -0,0 +1,30 @@
+//  
+//  213. House Robber II
+//  https://leetcode.com/problems/house-robber-ii/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/07/06.
+//  
+
+class Solution {
+  func rob(_ nums: [Int]) -> Int {
+    if nums.count < 3 { return nums.max()! }
+    var current = 0
+    var previous = 0
+    
+    // 첫 번째 집을 턴 경우
+    for element in nums.dropLast() {
+      (previous, current) = (current, max(element + previous, current))
+    }
+
+    var current2 = 0
+    var previous2 = 0
+
+    // 첫 번째 집을 털지 않은 경우
+    for element in nums.dropFirst() {
+      (previous2, current2) = (current2, max(element + previous2, current2))
+    }
+
+    return max(current, previous, current2, previous2)
+  }
+}

house-robber/WhiteHyun.swift

@@ -0,0 +1,19 @@
+//  
+//  198. House Robber
+//  https://leetcode.com/problems/house-robber/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/07/06.
+//  
+
+class Solution {
+  func rob(_ nums: [Int]) -> Int {
+    var previous = 0
+    var current = 0
+
+    for element in nums {
+      (previous, current) = (current, max(element + previous, current))
+    }
+    return max(previous, current)
+  }
+}

longest-palindromic-substring/WhiteHyun.swift

@@ -0,0 +1,39 @@
+//  
+//  5. Longest Palindromic Substring
+//  https://leetcode.com/problems/longest-palindromic-substring/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/07/06.
+//  
+
+class Solution {
+  func longestPalindrome(_ s: String) -> String {
+    let array = Array(s)
+    if array.count == 1 { return s }
+
+    var start = 0
+    var maxLength = 1
+
+    func expandAroundCenter(_ left: Int, _ right: Int) -> Int {
+      var l = left
+      var r = right
+      while l >= 0, r < array.count, array[l] == array[r] {
+        l -= 1
+        r += 1
+      }
+      return r - l - 1
+    }
+
+    for index in array.indices {
+      let length1 = expandAroundCenter(index, index) // 홀수 길이
+      let length2 = expandAroundCenter(index, index + 1) // 짝수 길이
+      let length = max(length1, length2)
+
+      if length > maxLength {
+        start = index - (length - 1) / 2
+        maxLength = length
+      }
+    }
+    return String(array[start ..< start + maxLength])
+  }
+}

number-of-connected-components-in-an-undirected-graph/WhiteHyun.swift

@@ -0,0 +1,40 @@
+//  
+//  323. Number of Connected Components in an Undirected Graph
+//  https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/07/06.
+//  
+
+final class Solution {
+  func countComponents(_ n: Int, _ edges: [[Int]]) -> Int {
+    var visited: Set<Int> = []
+    var count = 0
+
+    var graph: [Int: [Int]] = [:]
+
+    for edge in edges {
+      graph[edge[0], default: []].append(edge[1])
+      graph[edge[1], default: []].append(edge[0])
+    }
+
+    func dfs(_ node: Int) {
+      if visited.contains(node) {
+        return
+      }
+
+      visited.insert(node)
+
+      for nextNode in graph[node, default: []] {
+        dfs(nextNode)
+      }
+    }
+
+    for node in 0 ..< n where !visited.contains(node) {
+      count += 1
+      dfs(node)
+    }
+
+    return count
+  }
+}