diff --git a/articles/add-two-numbers.md b/articles/add-two-numbers.md
index 6225ac227..118adab49 100644
--- a/articles/add-two-numbers.md
+++ b/articles/add-two-numbers.md
@@ -303,6 +303,40 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    private func add(_ l1: ListNode?, _ l2: ListNode?, _ carry: Int) -> ListNode? {
+        if l1 == nil && l2 == nil && carry == 0 {
+            return nil
+        }
+        
+        let v1 = l1?.val ?? 0
+        let v2 = l2?.val ?? 0
+        
+        let sum = v1 + v2 + carry
+        let newCarry = sum / 10
+        let val = sum % 10
+        
+        let nextNode = add(l1?.next, l2?.next, newCarry)
+        return ListNode(val, nextNode)
+    }
+
+    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
+        return add(l1, l2, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -577,11 +611,49 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
+        let dummy = ListNode(0)
+        var cur = dummy
+        var l1 = l1, l2 = l2
+        var carry = 0
+
+        while l1 != nil || l2 != nil || carry != 0 {
+            let v1 = l1?.val ?? 0
+            let v2 = l2?.val ?? 0
+
+            let sum = v1 + v2 + carry
+            carry = sum / 10
+            let val = sum % 10
+            cur.next = ListNode(val)
+
+            cur = cur.next!
+            l1 = l1?.next
+            l2 = l2?.next
+        }
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(m + n)$
-* Space complexity: $O(1)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(max(m, n))$ for the output list.
 
 > Where $m$ is the length of $l1$ and $n$ is the length of $l2$.
\ No newline at end of file
diff --git a/articles/anagram-groups.md b/articles/anagram-groups.md
index a0aae3216..bf41aaa79 100644
--- a/articles/anagram-groups.md
+++ b/articles/anagram-groups.md
@@ -125,6 +125,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func groupAnagrams(_ strs: [String]) -> [[String]] {
+        var res = [String: [String]]()
+
+        for s in strs {
+            let sortedS = String(s.sorted())
+            res[sortedS, default: []].append(s)
+        }
+
+        return Array(res.values)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -277,11 +292,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func groupAnagrams(_ strs: [String]) -> [[String]] {
+        var res = [Array<Int>: [String]]()
+
+        for s in strs {
+            var count = [Int](repeating: 0, count: 26)
+            for c in s {
+                count[Int(c.asciiValue!) - 97] += 1
+            }
+            res[count, default: []].append(s)
+        }
+
+        return Array(res.values)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(m * n)$
-* Space complexity: $O(m)$
+* Space complexity:
+    * $O(m)$ extra space.
+    * $O(m * n)$ space for the output list.
 
-> Where $m$ is the number of strings and $n$ is the length of the longest string.
+> Where $m$ is the number of strings and $n$ is the length of the longest string.
\ No newline at end of file
diff --git a/articles/balanced-binary-tree.md b/articles/balanced-binary-tree.md
index c9c407ed0..21715bc6f 100644
--- a/articles/balanced-binary-tree.md
+++ b/articles/balanced-binary-tree.md
@@ -254,6 +254,43 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isBalanced(_ root: TreeNode?) -> Bool {
+        guard let root = root else { return true }
+
+        let left = height(root.left)
+        let right = height(root.right)
+
+        if abs(left - right) > 1 {
+            return false
+        }
+
+        return isBalanced(root.left) && isBalanced(root.right)
+    }
+
+    private func height(_ root: TreeNode?) -> Int {
+        guard let root = root else { return 0 }
+        return 1 + max(height(root.left), height(root.right))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -521,6 +558,39 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isBalanced(_ root: TreeNode?) -> Bool {
+        return dfs(root).0
+    }
+
+    private func dfs(_ root: TreeNode?) -> (Bool, Int) {
+        guard let root = root else { return (true, 0) }
+
+        let left = dfs(root.left)
+        let right = dfs(root.right)
+
+        let balanced = left.0 && right.0 && abs(left.1 - right.1) <= 1
+        return (balanced, 1 + max(left.1, right.1))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -534,7 +604,7 @@ class Solution {
 
 ---
 
-## 3. Depth First Search (Stack)
+## 3. Iterative DFS
 
 ::tabs-start
 
@@ -866,6 +936,58 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isBalanced(_ root: TreeNode?) -> Bool {
+        var stack = [TreeNode]()
+        var node = root
+        var last: TreeNode? = nil
+        var depths = [ObjectIdentifier: Int]()
+
+        while !stack.isEmpty || node != nil {
+            if let current = node {
+                stack.append(current)
+                node = current.left
+            } else {
+                guard let current = stack.last else { break }
+                if current.right == nil || last === current.right {
+                    stack.removeLast()
+
+                    let leftDepth = current.left != nil ? depths[ObjectIdentifier(current.left!)] ?? 0 : 0
+                    let rightDepth = current.right != nil ? depths[ObjectIdentifier(current.right!)] ?? 0 : 0
+                    if abs(leftDepth - rightDepth) > 1 {
+                        return false
+                    }
+
+                    depths[ObjectIdentifier(current)] = 1 + max(leftDepth, rightDepth)
+                    last = current
+                    node = nil
+                } else {
+                    node = current.right
+                }
+            }
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-search.md b/articles/binary-search.md
index 5e88782ce..59a970a26 100644
--- a/articles/binary-search.md
+++ b/articles/binary-search.md
@@ -139,6 +139,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func binarySearch(_ l: Int, _ r: Int, _ nums: [Int], _ target: Int) -> Int {
+        if l > r {
+            return -1
+        }
+        let m = l + (r - l) / 2
+
+        if nums[m] == target {
+            return m
+        }
+        if nums[m] < target {
+            return binarySearch(m + 1, r, nums, target)
+        }
+        return binarySearch(l, m - 1, nums, target)
+    }
+
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        return binarySearch(0, nums.count - 1, nums, target)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -296,6 +319,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        var l = 0, r = nums.count - 1
+
+        while l <= r {
+            // (l + r) // 2 can lead to overflow
+            let m = l + (r - l) / 2
+
+            if nums[m] > target {
+                r = m - 1
+            } else if nums[m] < target {
+                l = m + 1
+            } else {
+                return m
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -439,6 +484,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        var l = 0, r = nums.count
+
+        while l < r {
+            let m = l + (r - l) / 2  
+            if nums[m] > target {
+                r = m
+            } else {
+                l = m + 1
+            }
+        }
+        return (l > 0 && nums[l - 1] == target) ? l - 1 : -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -582,6 +645,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        var l = 0, r = nums.count
+
+        while l < r {
+            let m = l + (r - l) / 2  
+            if nums[m] >= target {
+                r = m
+            } else {
+                l = m + 1
+            }
+        }
+        return (l < nums.count && nums[l] == target) ? l : -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -664,6 +745,15 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        let index = nums.partitioningIndex { $0 >= target }
+        return (index < nums.count && nums[index] == target) ? index : -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-diameter.md b/articles/binary-tree-diameter.md
index 3c73fbe92..b11c3e40e 100644
--- a/articles/binary-tree-diameter.md
+++ b/articles/binary-tree-diameter.md
@@ -259,6 +259,41 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func diameterOfBinaryTree(_ root: TreeNode?) -> Int {
+        guard let root = root else { return 0 }
+
+        let leftHeight = maxHeight(root.left)
+        let rightHeight = maxHeight(root.right)
+        let diameter = leftHeight + rightHeight
+        let sub = max(diameterOfBinaryTree(root.left), diameterOfBinaryTree(root.right))
+        
+        return max(diameter, sub)
+    }
+
+    private func maxHeight(_ root: TreeNode?) -> Int {
+        guard let root = root else { return 0 }
+        return 1 + max(maxHeight(root.left), maxHeight(root.right))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -515,6 +550,40 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func diameterOfBinaryTree(_ root: TreeNode?) -> Int {
+        var res = 0
+
+        func dfs(_ root: TreeNode?) -> Int {
+            guard let root = root else { return 0 }
+            let left = dfs(root.left)
+            let right = dfs(root.right)
+            res = max(res, left + right)
+            return 1 + max(left, right)
+        }
+
+        dfs(root)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -876,6 +945,49 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func diameterOfBinaryTree(_ root: TreeNode?) -> Int {
+        guard let root = root else { return 0 }
+        var stack: [TreeNode] = [root]
+        var mp = [ObjectIdentifier: (Int, Int)]()
+
+        while !stack.isEmpty {
+            let node = stack.last!
+            if let left = node.left, mp[ObjectIdentifier(left)] == nil {
+                stack.append(left)
+            } else if let right = node.right, mp[ObjectIdentifier(right)] == nil {
+                stack.append(right)
+            } else {
+                let node = stack.removeLast()
+                let leftTuple = node.left != nil ? mp[ObjectIdentifier(node.left!)]! : (0, 0)
+                let rightTuple = node.right != nil ? mp[ObjectIdentifier(node.right!)]! : (0, 0)
+                let height = 1 + max(leftTuple.0, rightTuple.0)
+                let diameter = max(leftTuple.0 + rightTuple.0, leftTuple.1, rightTuple.1)
+                mp[ObjectIdentifier(node)] = (height, diameter)
+            }
+        }
+
+        return mp[ObjectIdentifier(root)]!.1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-from-preorder-and-inorder-traversal.md b/articles/binary-tree-from-preorder-and-inorder-traversal.md
index 621fc91cd..b21106a35 100644
--- a/articles/binary-tree-from-preorder-and-inorder-traversal.md
+++ b/articles/binary-tree-from-preorder-and-inorder-traversal.md
@@ -235,6 +235,49 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
+        if preorder.isEmpty || inorder.isEmpty {
+            return nil
+        }
+
+        let rootValue = preorder[0]
+        let root = TreeNode(rootValue)
+        guard let mid = inorder.firstIndex(of: rootValue) else {
+            return root
+        }
+
+        root.left = buildTree(
+            Array(preorder[1..<(mid + 1)]), 
+            Array(inorder[0..<mid])
+        )
+
+        root.right = buildTree(
+            Array(preorder[(mid + 1)..<preorder.count]), 
+            Array(inorder[(mid + 1)..<inorder.count])
+        )
+
+        return root
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -507,6 +550,51 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    var preIndex = 0
+    var indexMap = [Int: Int]()
+
+    func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
+        for (index, value) in inorder.enumerated() {
+            indexMap[value] = index
+        }
+        return dfs(preorder, 0, inorder.count - 1)
+    }
+
+    private func dfs(_ preorder: [Int], _ left: Int, _ right: Int) -> TreeNode? {
+        if left > right {
+            return nil
+        }
+
+        let rootVal = preorder[preIndex]
+        preIndex += 1
+        let root = TreeNode(rootVal)
+        let mid = indexMap[rootVal]!
+
+        root.left = dfs(preorder, left, mid - 1)
+        root.right = dfs(preorder, mid + 1, right)
+
+        return root
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -775,6 +863,48 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    var preIdx = 0
+    var inIdx = 0
+
+    func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
+        return dfs(preorder, inorder, Int.max)
+    }
+
+    private func dfs(_ preorder: [Int], _ inorder: [Int], _ limit: Int) -> TreeNode? {
+        if preIdx >= preorder.count {
+            return nil
+        }
+        if inorder[inIdx] == limit {
+            inIdx += 1
+            return nil
+        }
+
+        let root = TreeNode(preorder[preIdx])
+        preIdx += 1
+        root.left = dfs(preorder, inorder, root.val)
+        root.right = dfs(preorder, inorder, limit)
+        return root
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-maximum-path-sum.md b/articles/binary-tree-maximum-path-sum.md
index af442201a..ebd5467bc 100644
--- a/articles/binary-tree-maximum-path-sum.md
+++ b/articles/binary-tree-maximum-path-sum.md
@@ -290,6 +290,49 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    var res = Int.min
+
+    func maxPathSum(_ root: TreeNode?) -> Int {
+        dfs(root)
+        return res
+    }
+
+    private func dfs(_ root: TreeNode?) {
+        guard let node = root else { return }
+        let left = getMax(node.left)
+        let right = getMax(node.right)
+        res = max(res, node.val + left + right)
+        dfs(node.left)
+        dfs(node.right)
+    }
+
+    private func getMax(_ root: TreeNode?) -> Int {
+        guard let node = root else { return 0 }
+        let left = getMax(node.left)
+        let right = getMax(node.right)
+        let path = node.val + max(left, right)
+        return max(0, path)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -560,6 +603,42 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func maxPathSum(_ root: TreeNode?) -> Int {
+        var res = root!.val
+
+        func dfs(_ root: TreeNode?) -> Int {
+            guard let node = root else { return 0 }
+
+            let leftMax = max(dfs(node.left), 0)
+            let rightMax = max(dfs(node.right), 0)
+
+            res = max(res, node.val + leftMax + rightMax)
+            return node.val + max(leftMax, rightMax)
+        }
+
+        dfs(root)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-right-side-view.md b/articles/binary-tree-right-side-view.md
index e17b22299..4d8a68b19 100644
--- a/articles/binary-tree-right-side-view.md
+++ b/articles/binary-tree-right-side-view.md
@@ -236,6 +236,42 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func rightSideView(_ root: TreeNode?) -> [Int] {
+        var res = [Int]()
+
+        func dfs(_ node: TreeNode?, _ depth: Int) {
+            guard let node = node else { return }
+            if depth == res.count {
+                res.append(node.val)
+            }
+
+            dfs(node.right, depth + 1)
+            dfs(node.left, depth + 1)
+        }
+
+        dfs(root, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -530,6 +566,48 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func rightSideView(_ root: TreeNode?) -> [Int] {
+        var res = [Int]()
+        var q = Deque<TreeNode?>()
+        q.append(root)
+
+        while !q.isEmpty {
+            var rightSide: TreeNode?
+            let qLen = q.count
+
+            for _ in 0..<qLen {
+                if let node = q.removeFirst() {
+                    rightSide = node
+                    q.append(node.left)
+                    q.append(node.right)
+                }
+            }
+            if let rightSide = rightSide {
+                res.append(rightSide.val)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/burst-balloons.md b/articles/burst-balloons.md
index 3febbdd81..a52c66027 100644
--- a/articles/burst-balloons.md
+++ b/articles/burst-balloons.md
@@ -189,6 +189,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxCoins(_ nums: [Int]) -> Int {
+        var nums = [1] + nums + [1]
+
+        func dfs(_ nums: [Int]) -> Int {
+            if nums.count == 2 {
+                return 0
+            }
+
+            var maxCoins = 0
+            for i in 1..<(nums.count - 1) {
+                let coins = nums[i - 1] * nums[i] * nums[i + 1] +
+                            dfs(Array(nums[..<i]) + Array(nums[(i + 1)...]))
+                maxCoins = max(maxCoins, coins)
+            }
+            return maxCoins
+        }
+
+        return dfs(nums)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -430,6 +454,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxCoins(_ nums: [Int]) -> Int {
+        var nums = [1] + nums + [1]
+        let n = nums.count
+        var dp = Array(repeating: Array(repeating: -1, count: n), count: n)
+
+        func dfs(_ l: Int, _ r: Int) -> Int {
+            if l > r {
+                return 0
+            }
+            if dp[l][r] != -1 {
+                return dp[l][r]
+            }
+
+            dp[l][r] = 0
+            for i in l...r {
+                let coins = nums[l - 1] * nums[i] * nums[r + 1] + dfs(l, i - 1) + dfs(i + 1, r)
+                dp[l][r] = max(dp[l][r], coins)
+            }
+            return dp[l][r]
+        }
+
+        return dfs(1, n - 2)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -621,6 +673,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxCoins(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var newNums = [1] + nums + [1]
+
+        var dp = Array(repeating: Array(repeating: 0, count: n + 2), count: n + 2)
+
+        for l in stride(from: n, through: 1, by: -1) {
+            for r in l...n {
+                for i in l...r {
+                    let coins = (newNums[l - 1] * newNums[i] * newNums[r + 1]) +
+                                dp[l][i - 1] + dp[i + 1][r]
+                    dp[l][r] = max(dp[l][r], coins)
+                }
+            }
+        }
+
+        return dp[1][n]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/buy-and-sell-crypto-with-cooldown.md b/articles/buy-and-sell-crypto-with-cooldown.md
index 366028454..9c4ae550b 100644
--- a/articles/buy-and-sell-crypto-with-cooldown.md
+++ b/articles/buy-and-sell-crypto-with-cooldown.md
@@ -171,6 +171,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        let n = prices.count
+
+        func dfs(_ i: Int, _ buying: Bool) -> Int {
+            if i >= n {
+                return 0
+            }
+
+            let cooldown = dfs(i + 1, buying)
+            if buying {
+                let buy = dfs(i + 1, false) - prices[i]
+                return max(buy, cooldown)
+            } else {
+                let sell = dfs(i + 2, true) + prices[i]
+                return max(sell, cooldown)
+            }
+        }
+
+        return dfs(0, true)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -412,6 +437,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        let n = prices.count
+        var dp = [[Int?]](repeating: [Int?](repeating: nil, count: 2), count: n)
+
+        func dfs(_ i: Int, _ buying: Int) -> Int {
+            if i >= n {
+                return 0
+            }
+            if let cached = dp[i][buying] {
+                return cached
+            }
+
+            let cooldown = dfs(i + 1, buying)
+            if buying == 1 {
+                let buy = dfs(i + 1, 0) - prices[i]
+                dp[i][buying] = max(buy, cooldown)
+            } else {
+                let sell = dfs(i + 2, 1) + prices[i]
+                dp[i][buying] = max(sell, cooldown)
+            }
+            return dp[i][buying]!
+        }
+
+        return dfs(0, 1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -611,6 +666,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        let n = prices.count
+        var dp = Array(repeating: [0, 0], count: n + 1)
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            for buying in 0...1 {
+                if buying == 1 {
+                    let buy = (i + 1 < n ? dp[i + 1][0] - prices[i] : -prices[i])
+                    let cooldown = (i + 1 < n ? dp[i + 1][1] : 0)
+                    dp[i][1] = max(buy, cooldown)
+                } else {
+                    let sell = (i + 2 < n ? dp[i + 2][1] + prices[i] : prices[i])
+                    let cooldown = (i + 1 < n ? dp[i + 1][0] : 0)
+                    dp[i][0] = max(sell, cooldown)
+                }
+            }
+        }
+
+        return dp[0][1]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -769,6 +849,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        let n = prices.count
+        var dp1Buy = 0, dp1Sell = 0
+        var dp2Buy = 0
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            let dpBuy = max(dp1Sell - prices[i], dp1Buy)
+            let dpSell = max(dp2Buy + prices[i], dp1Sell)
+            dp2Buy = dp1Buy
+            dp1Buy = dpBuy
+            dp1Sell = dpSell
+        }
+
+        return dp1Buy
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/buy-and-sell-crypto.md b/articles/buy-and-sell-crypto.md
index 0e618efd5..b983fd272 100644
--- a/articles/buy-and-sell-crypto.md
+++ b/articles/buy-and-sell-crypto.md
@@ -120,6 +120,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        var res = 0
+        for i in 0..<prices.count {
+            let buy = prices[i]
+            for j in (i + 1)..<prices.count {
+                let sell = prices[j]
+                res = max(res, sell - buy)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -275,6 +291,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        var l = 0, r = 1
+        var maxP = 0
+
+        while r < prices.count {
+            if prices[l] < prices[r] {
+                let profit = prices[r] - prices[l]
+                maxP = max(maxP, profit)
+            } else {
+                l = r
+            }
+            r += 1
+        }
+        return maxP
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -397,6 +433,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        var maxP = 0
+        var minBuy = prices[0]
+
+        for sell in prices {
+            maxP = max(maxP, sell - minBuy)
+            minBuy = min(minBuy, sell)
+        }
+        return maxP
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/car-fleet.md b/articles/car-fleet.md
index 2d4e2ef35..22c7a9d0f 100644
--- a/articles/car-fleet.md
+++ b/articles/car-fleet.md
@@ -150,6 +150,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func carFleet(_ target: Int, _ position: [Int], _ speed: [Int]) -> Int {
+        var pair = zip(position, speed).map { ($0, $1) }
+        pair.sort { $0.0 > $1.0 } // Sort in descending order by position
+
+        var stack = [Double]()
+
+        for (p, s) in pair {
+            stack.append(Double(target - p) / Double(s))
+            if stack.count >= 2 && stack.last! <= stack[stack.count - 2] {
+                stack.removeLast()
+            }
+        }
+
+        return stack.count
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -327,6 +347,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func carFleet(_ target: Int, _ position: [Int], _ speed: [Int]) -> Int {
+        var pair = zip(position, speed).map { ($0, $1) }
+        pair.sort { $0.0 > $1.0 } // Sort in descending order by position
+
+        var fleets = 1
+        var prevTime = Double(target - pair[0].0) / Double(pair[0].1)
+
+        for i in 1..<pair.count {
+            let currCar = pair[i]
+            let currTime = Double(target - currCar.0) / Double(currCar.1)
+
+            if currTime > prevTime {
+                fleets += 1
+                prevTime = currTime
+            }
+        }
+
+        return fleets
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/cheapest-flight-path.md b/articles/cheapest-flight-path.md
index 6c23351be..976640249 100644
--- a/articles/cheapest-flight-path.md
+++ b/articles/cheapest-flight-path.md
@@ -258,6 +258,53 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let cost: Int
+    let node: Int
+    let stops: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.cost < rhs.cost
+    }
+}
+
+class Solution {
+    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ k: Int) -> Int {
+        let INF = Int.max
+        var adj = Array(repeating: [(Int, Int)](), count: n)
+        var dist = Array(repeating: Array(repeating: INF, count: k + 5), count: n)
+
+        for flight in flights {
+            let u = flight[0], v = flight[1], cst = flight[2]
+            adj[u].append((v, cst))
+        }
+
+        var minHeap = Heap<Item>()
+        minHeap.insert(Item(cost: 0, node: src, stops: -1))
+        dist[src][0] = 0
+
+        while !minHeap.isEmpty {
+            let item = minHeap.removeMin()
+            let cst = item.cost, node = item.node, stops = item.stops
+            if node == dst { return cst }
+            if stops == k || dist[node][stops + 1] < cst { continue }
+
+            for (nei, w) in adj[node] {
+                let nextCst = cst + w
+                let nextStops = stops + 1
+                if dist[nei][nextStops + 1] > nextCst {
+                    dist[nei][nextStops + 1] = nextCst
+                    minHeap.insert(Item(cost: nextCst, node: nei, stops: nextStops))
+                }
+            }
+        }
+
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -471,6 +518,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ k: Int) -> Int {
+        var prices = Array(repeating: Int.max, count: n)
+        prices[src] = 0
+
+        for _ in 0...k {
+            var tmpPrices = prices
+
+            for flight in flights {
+                let s = flight[0], d = flight[1], p = flight[2]
+                if prices[s] == Int.max {
+                    continue
+                }
+                if prices[s] + p < tmpPrices[d] {
+                    tmpPrices[d] = prices[s] + p
+                }
+            }
+            prices = tmpPrices
+        }
+        return prices[dst] == Int.max ? -1 : prices[dst]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -727,6 +799,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ k: Int) -> Int {
+        var prices = Array(repeating: Int.max, count: n)
+        prices[src] = 0
+        var adj = Array(repeating: [(Int, Int)](), count: n)
+
+        for flight in flights {
+            let u = flight[0], v = flight[1], cst = flight[2]
+            adj[u].append((v, cst))
+        }
+
+        var queue = Deque<(Int, Int, Int)>()
+        queue.append((0, src, 0))
+
+        while !queue.isEmpty {
+            let (cst, node, stops) = queue.popFirst()!
+            if stops > k {
+                continue
+            }
+
+            for (nei, w) in adj[node] {
+                let nextCost = cst + w
+                if nextCost < prices[nei] {
+                    prices[nei] = nextCost
+                    queue.append((nextCost, nei, stops + 1))
+                }
+            }
+        }
+
+        return prices[dst] == Int.max ? -1 : prices[dst]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/climbing-stairs.md b/articles/climbing-stairs.md
index a1a70e0fa..126511582 100644
--- a/articles/climbing-stairs.md
+++ b/articles/climbing-stairs.md
@@ -99,6 +99,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func climbStairs(_ n: Int) -> Int {
+        func dfs(_ i: Int) -> Int {
+            if i >= n {
+                return i == n ? 1 : 0
+            }
+            return dfs(i + 1) + dfs(i + 2)
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -240,6 +255,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func climbStairs(_ n: Int) -> Int {
+        var cache = Array(repeating: -1, count: n)
+        
+        func dfs(_ i: Int) -> Int {
+            if i >= n {
+                return i == n ? 1 : 0
+            }
+            if cache[i] != -1 {
+                return cache[i]
+            }
+            cache[i] = dfs(i + 1) + dfs(i + 2)
+            return cache[i]
+        }
+        
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -368,6 +404,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func climbStairs(_ n: Int) -> Int {
+        if n <= 2 {
+            return n
+        }
+        var dp = Array(repeating: 0, count: n + 1)
+        dp[1] = 1
+        dp[2] = 2
+        for i in 3...n {
+            dp[i] = dp[i - 1] + dp[i - 2]
+        }
+        return dp[n]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -495,6 +548,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func climbStairs(_ n: Int) -> Int {
+        var one = 1, two = 1
+
+        for _ in 0..<(n - 1) {
+            let temp = one
+            one = one + two
+            two = temp
+        }
+        
+        return one
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -764,6 +833,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func climbStairs(_ n: Int) -> Int {
+        if n == 1 {
+            return 1
+        }
+
+        func matrixMult(_ A: [[Int]], _ B: [[Int]]) -> [[Int]] {
+            return [
+                [A[0][0] * B[0][0] + A[0][1] * B[1][0], 
+                 A[0][0] * B[0][1] + A[0][1] * B[1][1]],
+                [A[1][0] * B[0][0] + A[1][1] * B[1][0], 
+                 A[1][0] * B[0][1] + A[1][1] * B[1][1]]
+            ]
+        }
+
+        func matrixPow(_ M: [[Int]], _ p: Int) -> [[Int]] {
+            var result = [[1, 0], [0, 1]]
+            var base = M
+            var power = p
+
+            while power > 0 {
+                if power % 2 == 1 {
+                    result = matrixMult(result, base)
+                }
+                base = matrixMult(base, base)
+                power /= 2
+            }
+
+            return result
+        }
+
+        let M = [[1, 1], [1, 0]]
+        let result = matrixPow(M, n)
+        return result[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -865,6 +973,18 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func climbStairs(_ n: Int) -> Int {
+        let sqrt5 = sqrt(5.0)
+        let phi = (1.0 + sqrt5) / 2.0
+        let psi = (1.0 - sqrt5) / 2.0
+        let n = n + 1
+        return Int(round((pow(phi, Double(n)) - pow(psi, Double(n))) / sqrt5))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/clone-graph.md b/articles/clone-graph.md
index ff2612c4c..e71e55184 100644
--- a/articles/clone-graph.md
+++ b/articles/clone-graph.md
@@ -290,6 +290,47 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * 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 {
+    func cloneGraph(_ node: Node?) -> Node? {
+        var oldToNew = [Node: Node]()
+        
+        func dfs(_ node: Node?) -> Node? {
+            guard let node = node else { return nil }
+            
+            if let existingCopy = oldToNew[node] {
+                return existingCopy
+            }
+            
+            let copy = Node(node.val)
+            oldToNew[node] = copy
+            
+            for neighbor in node.neighbors {
+                if let clonedNeighbor = dfs(neighbor) {
+                    copy.neighbors.append(clonedNeighbor)
+                }
+            }
+            
+            return copy
+        }
+        
+        return dfs(node)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -582,6 +623,49 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * 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 {
+    func cloneGraph(_ node: Node?) -> Node? {
+        if node == nil {
+            return nil
+        }
+
+        var oldToNew: [Node: Node] = [:]
+        let newNode = Node(node!.val)
+        oldToNew[node!] = newNode
+        var queue = Deque<Node>()
+        queue.append(node!)
+
+        while !queue.isEmpty {
+            let cur = queue.popFirst()!
+            for nei in cur.neighbors {
+                if let nei = nei {
+                    if oldToNew[nei] == nil {
+                        oldToNew[nei] = Node(nei.val)
+                        queue.append(nei)
+                    }
+                    oldToNew[cur]!.neighbors.append(oldToNew[nei]!)
+                }
+            }
+        }
+
+        return oldToNew[node!]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/coin-change-ii.md b/articles/coin-change-ii.md
index cdfd83983..6e4cce788 100644
--- a/articles/coin-change-ii.md
+++ b/articles/coin-change-ii.md
@@ -178,6 +178,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func change(_ amount: Int, _ coins: [Int]) -> Int {
+        let coins = coins.sorted()
+
+        func dfs(_ i: Int, _ a: Int) -> Int {
+            if a == 0 {
+                return 1
+            }
+            if i >= coins.count {
+                return 0
+            }
+
+            var res = 0
+            if a >= coins[i] {
+                res = dfs(i + 1, a)
+                res += dfs(i, a - coins[i])
+            }
+            return res
+        }
+
+        return dfs(0, amount)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -399,6 +425,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func change(_ amount: Int, _ coins: [Int]) -> Int {
+        let coins = coins.sorted()
+        var memo = Array(repeating: Array(repeating: -1, count: amount + 1), count: coins.count + 1)
+        
+        func dfs(_ i: Int, _ a: Int) -> Int {
+            if a == 0 {
+                return 1
+            }
+            if i >= coins.count {
+                return 0
+            }
+            if memo[i][a] != -1 {
+                return memo[i][a]
+            }
+            
+            var res = 0
+            if a >= coins[i] {
+                res = dfs(i + 1, a)
+                res += dfs(i, a - coins[i])
+            }
+            
+            memo[i][a] = res
+            return res
+        }
+        
+        return dfs(0, amount)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -464,8 +522,8 @@ public:
     int change(int amount, vector<int>& coins) {
         int n = coins.size();
         sort(coins.begin(), coins.end());
-        vector<vector<int>> dp(n + 1, vector<int>(amount + 1, 0));
-        
+        vector<vector<uint>> dp(n + 1, vector<uint>(amount + 1, 0));
+
         for (int i = 0; i <= n; i++) {
             dp[i][0] = 1;
         }
@@ -592,6 +650,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func change(_ amount: Int, _ coins: [Int]) -> Int {
+        let n = coins.count
+        let sortedCoins = coins.sorted()
+        var dp = Array(
+            repeating: Array(repeating: 0, count: amount + 1),
+            count: n + 1
+        )
+        
+        for i in 0...n {
+            dp[i][0] = 1
+        }
+        
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            for a in 0...amount {
+                let base = dp[i + 1][a]
+                if a >= sortedCoins[i] {
+                    let addend = dp[i][a - sortedCoins[i]]
+                    if base > Int.max - addend {
+                        dp[i][a] = 0
+                    } else {
+                        dp[i][a] = base + addend
+                    }
+                } else {
+                    dp[i][a] = base
+                }
+            }
+        }
+        
+        return dp[0][amount]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -650,10 +743,10 @@ public class Solution {
 class Solution {
 public:
     int change(int amount, vector<int>& coins) {
-        vector<int> dp(amount + 1, 0);
+        vector<uint> dp(amount + 1, 0);
         dp[0] = 1;
         for (int i = coins.size() - 1; i >= 0; i--) {
-            vector<int> nextDP(amount + 1, 0);
+            vector<uint> nextDP(amount + 1, 0);
             nextDP[0] = 1;
 
             for (int a = 1; a <= amount; a++) {
@@ -764,6 +857,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func change(_ amount: Int, _ coins: [Int]) -> Int {
+        var dp = [Int](repeating: 0, count: amount + 1)
+        dp[0] = 1
+
+        for i in stride(from: coins.count - 1, through: 0, by: -1) {
+            var nextDP = [Int](repeating: 0, count: amount + 1)
+            nextDP[0] = 1
+
+            for a in 1..<(amount + 1) {
+                nextDP[a] = dp[a]
+                if a - coins[i] >= 0 {
+                    let addend = nextDP[a - coins[i]]
+                    if nextDP[a] > Int.max - addend {
+                        nextDP[a] = 0
+                    } else {
+                        nextDP[a] += addend
+                    }
+                }
+            }
+            
+            dp = nextDP
+        }
+
+        return dp[amount]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -807,7 +930,7 @@ public class Solution {
 class Solution {
 public:
     int change(int amount, vector<int>& coins) {
-        vector<int> dp(amount + 1, 0);
+        vector<uint> dp(amount + 1, 0);
         dp[0] = 1;
         for (int i = coins.size() - 1; i >= 0; i--) {
             for (int a = 1; a <= amount; a++) {
@@ -890,6 +1013,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func change(_ amount: Int, _ coins: [Int]) -> Int {
+        var dp = [Int](repeating: 0, count: amount + 1)
+        dp[0] = 1
+
+        for i in stride(from: coins.count - 1, through: 0, by: -1) {
+            for a in 1..<(amount + 1) {
+                if coins[i] <= a {
+                    let addend = dp[a - coins[i]]
+                    if dp[a] > Int.max - addend {
+                        dp[a] = 0
+                    } else {
+                        dp[a] += addend
+                    }
+                }
+            }
+        }
+
+        return dp[amount]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/coin-change.md b/articles/coin-change.md
index eb1f7e715..f61f99922 100644
--- a/articles/coin-change.md
+++ b/articles/coin-change.md
@@ -170,6 +170,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func coinChange(_ coins: [Int], _ amount: Int) -> Int {
+        func dfs(_ amount: Int) -> Int {
+            if amount == 0 {
+                return 0
+            }
+
+            var res = Int(1e9)
+            for coin in coins {
+                if amount - coin >= 0 {
+                    res = min(res, 1 + dfs(amount - coin))
+                }
+            }
+            return res
+        }
+
+        let minCoins = dfs(amount)
+        return minCoins >= Int(1e9) ? -1 : minCoins
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -393,6 +416,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func coinChange(_ coins: [Int], _ amount: Int) -> Int {
+        var memo = [Int: Int]()
+
+        func dfs(_ amount: Int) -> Int {
+            if amount == 0 {
+                return 0
+            }
+            if let cached = memo[amount] {
+                return cached
+            }
+
+            var res = Int(1e9)
+            for coin in coins {
+                if amount - coin >= 0 {
+                    res = min(res, 1 + dfs(amount - coin))
+                }
+            }
+
+            memo[amount] = res
+            return res
+        }
+
+        let minCoins = dfs(amount)
+        return minCoins >= Int(1e9) ? -1 : minCoins
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -542,6 +595,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func coinChange(_ coins: [Int], _ amount: Int) -> Int {
+        if amount == 0 {
+            return 0
+        }
+
+        var dp = [Int](repeating: amount + 1, count: amount + 1)
+        dp[0] = 0
+
+        for a in 1...amount {
+            for coin in coins {
+                if a - coin >= 0 {
+                    dp[a] = min(dp[a], 1 + dp[a - coin])
+                }
+            }
+        }
+
+        return dp[amount] == amount + 1 ? -1 : dp[amount]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -772,6 +848,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func coinChange(_ coins: [Int], _ amount: Int) -> Int {
+        if amount == 0 {
+            return 0
+        }
+
+        var q = Deque([0])
+        var seen = Array(repeating: false, count: amount + 1)
+        seen[0] = true
+        var res = 0  
+
+        while !q.isEmpty {
+            res += 1
+            for _ in 0..<q.count {
+                let cur = q.popFirst()!
+                for coin in coins {
+                    let nxt = cur + coin
+                    if nxt == amount {
+                        return res
+                    }
+                    if nxt > amount || seen[nxt] {
+                        continue
+                    }
+                    seen[nxt] = true
+                    q.append(nxt)
+                }
+            }
+        }
+
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/combination-target-sum-ii.md b/articles/combination-target-sum-ii.md
index 0c9a90f24..3b35aab6d 100644
--- a/articles/combination-target-sum-ii.md
+++ b/articles/combination-target-sum-ii.md
@@ -216,6 +216,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func combinationSum2(_ candidates: [Int], _ target: Int) -> [[Int]] {
+        var res = Set<[Int]>()
+        let sortedCandidates = candidates.sorted()
+
+        func generateSubsets(_ i: Int, _ cur: inout [Int], _ total: Int) {
+            if total == target {
+                res.insert(cur)
+                return
+            }
+            if total > target || i == sortedCandidates.count {
+                return
+            }
+
+            cur.append(sortedCandidates[i])
+            generateSubsets(i + 1, &cur, total + sortedCandidates[i])
+            cur.removeLast()
+
+            generateSubsets(i + 1, &cur, total)
+        }
+
+        var cur: [Int] = []
+        generateSubsets(0, &cur, 0)
+        return Array(res)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -464,6 +493,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func combinationSum2(_ candidates: [Int], _ target: Int) -> [[Int]] {
+        var res = [[Int]]()
+        let sortedCandidates = candidates.sorted()
+
+        func dfs(_ i: Int, _ cur: inout [Int], _ total: Int) {
+            if total == target {
+                res.append(cur)
+                return
+            }
+            if total > target || i == sortedCandidates.count {
+                return
+            }
+
+            cur.append(sortedCandidates[i])
+            dfs(i + 1, &cur, total + sortedCandidates[i])
+            cur.removeLast()
+
+            var j = i
+            while j + 1 < sortedCandidates.count && sortedCandidates[j] == sortedCandidates[j + 1] {
+                j += 1
+            }
+            dfs(j + 1, &cur, total)
+        }
+
+        var cur: [Int] = []
+        dfs(0, &cur, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -772,6 +834,47 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func combinationSum2(_ nums: [Int], _ target: Int) -> [[Int]] {
+        var res = [[Int]]()
+        var count = [Int: Int]()
+        var uniqueNums = [Int]()
+
+        for num in nums {
+            if count[num] == nil {
+                uniqueNums.append(num)
+            }
+            count[num, default: 0] += 1
+        }
+
+        func backtrack(_ nums: [Int], _ target: Int, _ cur: inout [Int], _ i: Int) {
+            if target == 0 {
+                res.append(cur)
+                return
+            }
+            if target < 0 || i >= nums.count {
+                return
+            }
+
+            if count[nums[i], default: 0] > 0 {
+                cur.append(nums[i])
+                count[nums[i], default: 0] -= 1
+                backtrack(nums, target - nums[i], &cur, i)
+                count[nums[i], default: 0] += 1
+                cur.removeLast()
+            }
+
+            backtrack(nums, target, &cur, i + 1)
+        }
+
+        var cur: [Int] = []
+        backtrack(uniqueNums, target, &cur, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1008,6 +1111,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func combinationSum2(_ candidates: [Int], _ target: Int) -> [[Int]] {
+        var res = [[Int]]()
+        let sortedCandidates = candidates.sorted()
+
+        func dfs(_ idx: Int, _ path: inout [Int], _ cur: Int) {
+            if cur == target {
+                res.append(path)
+                return
+            }
+
+            for i in idx..<sortedCandidates.count {
+                if i > idx && sortedCandidates[i] == sortedCandidates[i - 1] {
+                    continue
+                }
+                if cur + sortedCandidates[i] > target {
+                    break
+                }
+
+                path.append(sortedCandidates[i])
+                dfs(i + 1, &path, cur + sortedCandidates[i])
+                path.removeLast()
+            }
+        }
+
+        var path: [Int] = []
+        dfs(0, &path, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/combination-target-sum.md b/articles/combination-target-sum.md
index 43a9f3cd1..46436ad64 100644
--- a/articles/combination-target-sum.md
+++ b/articles/combination-target-sum.md
@@ -194,6 +194,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func combinationSum(_ nums: [Int], _ target: Int) -> [[Int]] {
+        var res: [[Int]] = []
+
+        func dfs(_ i: Int, _ cur: inout [Int], _ total: Int) {
+            if total == target {
+                res.append(cur)
+                return
+            }
+            if i >= nums.count || total > target {
+                return
+            }
+
+            cur.append(nums[i])
+            dfs(i, &cur, total + nums[i])
+            cur.removeLast()
+            dfs(i + 1, &cur, total)
+        }
+
+        var cur: [Int] = []
+        dfs(0, &cur, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -406,6 +433,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func combinationSum(_ nums: [Int], _ target: Int) -> [[Int]] {
+        var res: [[Int]] = []
+        let sortedNums = nums.sorted()
+
+        func dfs(_ i: Int, _ cur: inout [Int], _ total: Int) {
+            if total == target {
+                res.append(cur)
+                return
+            }
+
+            for j in i..<sortedNums.count {
+                if total + sortedNums[j] > target {
+                    return
+                }
+                cur.append(sortedNums[j])
+                dfs(j, &cur, total + sortedNums[j])
+                cur.removeLast()
+            }
+        }
+
+        var cur: [Int] = []
+        dfs(0, &cur, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/combinations-of-a-phone-number.md b/articles/combinations-of-a-phone-number.md
index 941f7ebf6..6f6bfd6dd 100644
--- a/articles/combinations-of-a-phone-number.md
+++ b/articles/combinations-of-a-phone-number.md
@@ -212,12 +212,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func letterCombinations(_ digits: String) -> [String] {
+        guard !digits.isEmpty else { return [] }
+        
+        let digitToChar: [Character: String] = [
+            "2": "abc", "3": "def", "4": "ghi", "5": "jkl",
+            "6": "mno", "7": "pqrs", "8": "tuv", "9": "wxyz"
+        ]
+        
+        var res = [String]()
+        let digitsArray = Array(digits)
+        
+        func backtrack(_ i: Int, _ curStr: String) {
+            if curStr.count == digits.count {
+                res.append(curStr)
+                return
+            }
+            if let letters = digitToChar[digitsArray[i]] {
+                for c in letters {
+                    backtrack(i + 1, curStr + String(c))
+                }
+            }
+        }
+        
+        backtrack(0, "")
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 4 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(n * 4 ^ n)$ space for the output list.
 
 ---
 
@@ -429,9 +462,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func letterCombinations(_ digits: String) -> [String] {
+        guard !digits.isEmpty else { return [] }
+        
+        let digitToChar: [Character: String] = [
+            "2": "abc", "3": "def", "4": "ghi", "5": "jkl",
+            "6": "mno", "7": "pqrs", "8": "tuv", "9": "wxyz"
+        ]
+        
+        var res = [""]
+        
+        for digit in digits {
+            guard let letters = digitToChar[digit] else { continue }
+            var tmp = [String]()
+            for curStr in res {
+                for c in letters {
+                    tmp.append(curStr + String(c))
+                }
+            }
+            res = tmp
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 4 ^ n)$
-* Space complexity: $O(n)$
\ No newline at end of file
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(n * 4 ^ n)$ space for the output list.
\ No newline at end of file
diff --git a/articles/copy-linked-list-with-random-pointer.md b/articles/copy-linked-list-with-random-pointer.md
index 2c8acaed9..0b595bf64 100644
--- a/articles/copy-linked-list-with-random-pointer.md
+++ b/articles/copy-linked-list-with-random-pointer.md
@@ -1,4 +1,4 @@
-## 1. Hash Map (Recursion)
+## 1. Recursion + Hash Map
 
 ::tabs-start
 
@@ -223,6 +223,44 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var next: Node?
+ *     public var random: Node?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *    	   self.random = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    private var map = [Node: Node]()
+    
+    func copyRandomList(_ head: Node?) -> Node? {
+        if head == nil {
+            return nil
+        }
+        
+        if let copied = map[head!] {
+            return copied
+        }
+        
+        let copy = Node(head!.val)
+        map[head!] = copy
+        
+        copy.next = copyRandomList(head!.next)
+        copy.random = copyRandomList(head!.random)
+        
+        return copy
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -494,6 +532,45 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var next: Node?
+ *     public var random: Node?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *    	   self.random = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func copyRandomList(_ head: Node?) -> Node? {
+        var oldToCopy: [Node?: Node?] = [nil: nil]
+
+        var cur = head
+        while cur != nil {
+            let copy = Node(cur!.val)
+            oldToCopy[cur] = copy
+            cur = cur?.next
+        }
+
+        cur = head
+        while cur != nil {
+            let copy = oldToCopy[cur]!
+            copy?.next = oldToCopy[cur?.next]!
+            copy?.random = oldToCopy[cur?.random]!
+            cur = cur?.next
+        }
+
+        return oldToCopy[head]!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -789,6 +866,46 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var next: Node?
+ *     public var random: Node?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *    	   self.random = nil
+ *     }
+ * }
+ */
+
+class Solution {
+   func copyRandomList(_ head: Node?) -> Node? {
+       var oldToCopy = [Node?: Node?]()
+
+       func getNode(_ node: Node?) -> Node? {
+           if node == nil { return nil }
+           if oldToCopy[node] == nil {
+               oldToCopy[node] = Node(0)
+           }
+           return oldToCopy[node]!
+       }
+
+       var cur = head
+       while cur != nil {
+           getNode(cur)!.val = cur!.val
+           getNode(cur)!.next = getNode(cur!.next)
+           getNode(cur)!.random = getNode(cur!.random)
+           cur = cur!.next
+       }
+
+       return getNode(head)
+   }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1161,12 +1278,67 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var next: Node?
+ *     public var random: Node?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *    	   self.random = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func copyRandomList(_ head: Node?) -> Node? {
+        if head == nil {
+            return nil
+        }
+        
+        var l1 = head
+        while l1 != nil {
+            let l2 = Node(l1!.val)
+            l2.next = l1?.next
+            l1?.next = l2
+            l1 = l2.next
+        }
+        
+        let newHead = head?.next
+        l1 = head
+        while l1 != nil {
+            if let random = l1?.random {
+                l1?.next?.random = random.next
+            }
+            l1 = l1?.next?.next
+        }
+        
+        l1 = head
+        while l1 != nil {
+            let l2 = l1?.next
+            l1?.next = l2?.next
+            if l2?.next != nil {
+                l2?.next = l2?.next?.next
+            }
+            l1 = l1?.next
+        }
+        
+        return newHead
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n)$
-* Space complexity: $O(1)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ for the output.
 
 ---
 
@@ -1525,9 +1697,62 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var next: Node?
+ *     public var random: Node?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *    	   self.random = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func copyRandomList(_ head: Node?) -> Node? {
+        if head == nil {
+            return nil
+        }
+
+        var l1 = head
+        while l1 != nil {
+            let l2 = Node(l1!.val)
+            l2.next = l1?.random
+            l1?.random = l2
+            l1 = l1?.next
+        }
+
+        let newHead = head?.random
+
+        l1 = head
+        while l1 != nil {
+            let l2 = l1?.random
+            l2?.random = l2?.next?.random
+            l1 = l1?.next
+        }
+
+        l1 = head
+        while l1 != nil {
+            let l2 = l1?.random
+            l1?.random = l2?.next
+            l2?.next = l1?.next?.random
+            l1 = l1?.next
+        }
+
+        return newHead
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n)$
-* Space complexity: $O(1)$
\ No newline at end of file
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ for the output.
\ No newline at end of file
diff --git a/articles/count-connected-components.md b/articles/count-connected-components.md
index 0f0dc28ba..c31580864 100644
--- a/articles/count-connected-components.md
+++ b/articles/count-connected-components.md
@@ -229,6 +229,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countComponents(_ n: Int, _ edges: [[Int]]) -> Int {
+        var adj = Array(repeating: [Int](), count: n)
+        var visit = Array(repeating: false, count: n)
+        
+        for edge in edges {
+            let u = edge[0], v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+        }
+        
+        func dfs(_ node: Int) {
+            for nei in adj[node] {
+                if !visit[nei] {
+                    visit[nei] = true
+                    dfs(nei)
+                }
+            }
+        }
+        
+        var res = 0
+        for node in 0..<n {
+            if !visit[node] {
+                visit[node] = true
+                dfs(node)
+                res += 1
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -506,6 +541,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countComponents(_ n: Int, _ edges: [[Int]]) -> Int {
+        var adj = Array(repeating: [Int](), count: n)
+        var visit = Array(repeating: false, count: n)
+        for edge in edges {
+            let u = edge[0], v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+        }
+        
+        func bfs(_ node: Int) {
+            var q = Deque<Int>()
+            q.append(node)
+            visit[node] = true
+            while !q.isEmpty {
+                let cur = q.removeFirst()
+                for nei in adj[cur] {
+                    if !visit[nei] {
+                        visit[nei] = true
+                        q.append(nei)
+                    }
+                }
+            }
+        }
+        
+        var res = 0
+        for node in 0..<n {
+            if !visit[node] {
+                bfs(node)
+                res += 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -556,7 +629,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     int[] parent;
     int[] rank;
 
@@ -877,6 +950,55 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    var parent: [Int]
+    var rank: [Int]
+    
+    init(_ n: Int) {
+        parent = Array(0..<n)
+        rank = Array(repeating: 1, count: n)
+    }
+    
+    func find(_ node: Int) -> Int {
+        var cur = node
+        while cur != parent[cur] {
+            parent[cur] = parent[parent[cur]]
+            cur = parent[cur]
+        }
+        return cur
+    }
+    
+    func union(_ u: Int, _ v: Int) -> Bool {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv { return false }
+        var rootU = pu
+        var rootV = pv
+        if rank[rootV] > rank[rootU] {
+            swap(&rootU, &rootV)
+        }
+        parent[rootV] = rootU
+        rank[rootU] += rank[rootV]
+        return true
+    }
+}
+
+class Solution {
+    func countComponents(_ n: Int, _ edges: [[Int]]) -> Int {
+        let dsu = DSU(n)
+        var res = n
+        for edge in edges {
+            let u = edge[0], v = edge[1]
+            if dsu.union(u, v) {
+                res -= 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/count-good-nodes-in-binary-tree.md b/articles/count-good-nodes-in-binary-tree.md
index 1eda1a860..d9356f32c 100644
--- a/articles/count-good-nodes-in-binary-tree.md
+++ b/articles/count-good-nodes-in-binary-tree.md
@@ -250,6 +250,39 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func goodNodes(_ root: TreeNode?) -> Int {
+        func dfs(_ node: TreeNode?, _ maxVal: Int) -> Int {
+            guard let node = node else { return 0 }
+
+            var res = node.val >= maxVal ? 1 : 0
+            let newMaxVal = max(maxVal, node.val)
+            res += dfs(node.left, newMaxVal)
+            res += dfs(node.right, newMaxVal)
+            return res
+        }
+
+        return dfs(root, root?.val ?? Int.min)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -545,6 +578,51 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func goodNodes(_ root: TreeNode?) -> Int {
+        guard let root = root else { return 0 }
+
+        var res = 0
+        var q = Deque<(TreeNode, Int)>()
+        q.append((root, Int.min))
+
+        while !q.isEmpty {
+            let (node, maxVal) = q.popFirst()!
+            if node.val >= maxVal {
+                res += 1
+            }
+
+            let newMaxVal = max(maxVal, node.val)
+
+            if let left = node.left {
+                q.append((left, newMaxVal))
+            }
+            if let right = node.right {
+                q.append((right, newMaxVal))
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/count-number-of-islands.md b/articles/count-number-of-islands.md
index cee406700..042d79082 100644
--- a/articles/count-number-of-islands.md
+++ b/articles/count-number-of-islands.md
@@ -236,6 +236,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numIslands(_ grid: [[Character]]) -> Int {
+        let directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        var islands = 0
+        var grid = grid
+
+        func dfs(_ r: Int, _ c: Int) {
+            if r < 0 || c < 0 || r >= ROWS || c >= COLS || grid[r][c] == "0" {
+                return
+            }
+
+            grid[r][c] = "0"
+            for dir in directions {
+                dfs(r + dir[0], c + dir[1])
+            }
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == "1" {
+                    dfs(r, c)
+                    islands += 1
+                }
+            }
+        }
+
+        return islands
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -542,6 +576,48 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numIslands(_ grid: [[Character]]) -> Int {
+        let directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        var islands = 0
+        var grid = grid
+
+        func bfs(_ r: Int, _ c: Int) {
+            var queue = Deque<(Int, Int)>()
+            grid[r][c] = "0"
+            queue.append((r, c))
+
+            while !queue.isEmpty {
+                let (row, col) = queue.popFirst()!
+                for dir in directions {
+                    let nr = row + dir[0]
+                    let nc = col + dir[1]
+                    if nr < 0 || nc < 0 || nr >= ROWS || nc >= COLS || grid[nr][nc] == "0" {
+                        continue
+                    }
+                    queue.append((nr, nc))
+                    grid[nr][nc] = "0"
+                }
+            }
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == "1" {
+                    bfs(r, c)
+                    islands += 1
+                }
+            }
+        }
+
+        return islands
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -610,7 +686,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     private int[] Parent, Size;
 
     public DSU(int n) {
@@ -1035,6 +1111,77 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    private var parent: [Int]
+    private var size: [Int]
+
+    init(_ n: Int) {
+        parent = Array(0...n)
+        size = Array(repeating: 1, count: n + 1)
+    }
+
+    func find(_ node: Int) -> Int {
+        if parent[node] != node {
+            parent[node] = find(parent[node])
+        }
+        return parent[node]
+    }
+
+    func union(_ u: Int, _ v: Int) -> Bool {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv {
+            return false
+        }
+        if size[pu] >= size[pv] {
+            size[pu] += size[pv]
+            parent[pv] = pu
+        } else {
+            size[pv] += size[pu]
+            parent[pu] = pv
+        }
+        return true
+    }
+}
+
+class Solution {
+    func numIslands(_ grid: [[Character]]) -> Int {
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        let dsu = DSU(ROWS * COLS)
+
+        func index(_ r: Int, _ c: Int) -> Int {
+            return r * COLS + c
+        }
+
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+        var islands = 0
+        var grid = grid
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == "1" {
+                    islands += 1
+                    for dir in directions {
+                        let nr = r + dir.0
+                        let nc = c + dir.1
+                        if nr < 0 || nc < 0 || nr >= ROWS || nc >= COLS || grid[nr][nc] == "0" {
+                            continue
+                        }
+                        if dsu.union(index(r, c), index(nr, nc)) {
+                            islands -= 1
+                        }
+                    }
+                }
+            }
+        }
+
+        return islands
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/count-paths.md b/articles/count-paths.md
index 61ab8e148..5db166df2 100644
--- a/articles/count-paths.md
+++ b/articles/count-paths.md
@@ -121,6 +121,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == m - 1 && j == n - 1 {
+                return 1
+            }
+            if i >= m || j >= n {
+                return 0
+            }
+            return dfs(i, j + 1) + dfs(i + 1, j)
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -304,6 +322,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var memo = Array(repeating: Array(repeating: -1, count: n), count: m)
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == m - 1 && j == n - 1 {
+                return 1
+            }
+            if i >= m || j >= n {
+                return 0
+            }
+            if memo[i][j] != -1 {
+                return memo[i][j]
+            }
+
+            memo[i][j] = dfs(i, j + 1) + dfs(i + 1, j)
+            return memo[i][j]
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -442,6 +485,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
+        dp[m - 1][n - 1] = 1
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                dp[i][j] += dp[i + 1][j] + dp[i][j + 1]
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -585,6 +645,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var row = Array(repeating: 1, count: n)
+
+        for _ in 0..<(m - 1) {
+            var newRow = Array(repeating: 1, count: n)
+            for j in stride(from: n - 2, through: 0, by: -1) {
+                newRow[j] = newRow[j + 1] + row[j]
+            }
+            row = newRow
+        }
+        return row[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -716,6 +793,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: 1, count: n)
+
+        for _ in stride(from: m - 2, through: 0, by: -1) {
+            for j in stride(from: n - 2, through: 0, by: -1) {
+                dp[j] += dp[j + 1]
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -896,6 +989,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        if m == 1 || n == 1 {
+            return 1
+        }
+        var m = m, n = n
+        if m < n {
+            swap(&m, &n)
+        }
+
+        var res = 1
+        var j = 1
+        for i in m..<(m + n - 1) {
+            res *= i
+            res /= j
+            j += 1
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/count-squares.md b/articles/count-squares.md
index 6b27ebb50..1b5defe8c 100644
--- a/articles/count-squares.md
+++ b/articles/count-squares.md
@@ -240,6 +240,40 @@ class CountSquares() {
 }
 ```
 
+```swift
+class CountSquares {
+    private var ptsCount: [String: Int]
+    private var pts: [[Int]]
+
+    init() {
+        self.ptsCount = [:]
+        self.pts = []
+    }
+
+    func add(_ point: [Int]) {
+        let key = "\(point[0]),\(point[1])"
+        ptsCount[key, default: 0] += 1
+        pts.append(point)
+    }
+
+    func count(_ point: [Int]) -> Int {
+        var res = 0
+        let px = point[0], py = point[1]
+
+        for pt in pts {
+            let x = pt[0], y = pt[1]
+            if abs(py - y) != abs(px - x) || x == px || y == py {
+                continue
+            }
+            let key1 = "\(x),\(py)"
+            let key2 = "\(px),\(y)"
+            res += (ptsCount[key1] ?? 0) * (ptsCount[key2] ?? 0)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -320,10 +354,9 @@ public class CountSquares {
 ```cpp
 class CountSquares {
     unordered_map<int, unordered_map<int, int>> ptsCount;
+
 public:
-    CountSquares() {
-        
-    }
+    CountSquares() {}
     
     void add(vector<int> point) {
         ptsCount[point[0]][point[1]]++;
@@ -531,6 +564,40 @@ class CountSquares {
 }
 ```
 
+```swift
+class CountSquares {
+    var ptsCount: [Int: [Int: Int]]
+    
+    init() {
+        ptsCount = [:]
+    }
+    
+    func add(_ point: [Int]) {
+        let x = point[0]
+        let y = point[1]
+        ptsCount[x, default: [:]][y, default: 0] += 1
+    }
+    
+    func count(_ point: [Int]) -> Int {
+        var res = 0
+        let x1 = point[0]
+        let y1 = point[1]
+
+        if let yMap = ptsCount[x1] {
+            for (y2, countXY2) in yMap {
+                let side = y2 - y1
+                if side == 0 { continue }
+                let x3 = x1 + side
+                let x4 = x1 - side
+                res += countXY2 * (ptsCount[x3]?[y1] ?? 0) * (ptsCount[x3]?[y2] ?? 0)
+                res += countXY2 * (ptsCount[x4]?[y1] ?? 0) * (ptsCount[x4]?[y2] ?? 0)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/count-subsequences.md b/articles/count-subsequences.md
index 04fd77389..241876a84 100644
--- a/articles/count-subsequences.md
+++ b/articles/count-subsequences.md
@@ -181,6 +181,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDistinct(_ s: String, _ t: String) -> Int {
+        let sArray = Array(s), tArray = Array(t)
+        let sLen = sArray.count, tLen = tArray.count
+        if tLen > sLen { return 0 }
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if j == tLen { return 1 }
+            if i == sLen { return 0 }
+            
+            var res = dfs(i + 1, j)
+            if sArray[i] == tArray[j] {
+                res += dfs(i + 1, j + 1)
+            }
+            return res
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -188,6 +211,8 @@ class Solution {
 * Time complexity: $O(2 ^ m)$
 * Space complexity: $O(m)$
 
+> Where $m$ is the length of the string $s$.
+
 ---
 
 ## 2. Dynamic Programming (Top-Down)
@@ -396,6 +421,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDistinct(_ s: String, _ t: String) -> Int {
+        let sArray = Array(s), tArray = Array(t)
+        let sLen = sArray.count, tLen = tArray.count
+        if tLen > sLen { return 0 }
+
+        var dp = [[Int]: Int]()
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if j == tLen { return 1 }
+            if i == sLen { return 0 }
+            if let val = dp[[i, j]] { return val }
+
+            var res = dfs(i + 1, j)
+            if sArray[i] == tArray[j] {
+                res += dfs(i + 1, j + 1)
+            }
+            dp[[i, j]] = res
+            return res
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -458,7 +510,7 @@ class Solution {
 public:
     int numDistinct(string s, string t) {
         int m = s.length(), n = t.length();
-        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
+        vector<vector<uint>> dp(m + 1, vector<uint>(n + 1, 0));
 
         for (int i = 0; i <= m; i++) {
             dp[i][n] = 1;
@@ -582,6 +634,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDistinct(_ s: String, _ t: String) -> Int {
+        let m = s.count, n = t.count
+        var dp = Array(
+            repeating: Array(repeating: 0, count: n + 1),
+            count: m + 1
+        )
+
+        let sArray = Array(s)
+        let tArray = Array(t)
+
+        for i in 0...m {
+            dp[i][n] = 1
+        }
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                let base = dp[i + 1][j]
+                dp[i][j] = base
+                if sArray[i] == tArray[j] {
+                    let addend = dp[i + 1][j + 1]
+                    if base > Int.max - addend {
+                        dp[i][j] = 0
+                    } else {
+                        dp[i][j] += addend
+                    }
+                }
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -643,8 +731,8 @@ class Solution {
 public:
     int numDistinct(string s, string t) {
         int m = s.size(), n = t.size();
-        vector<int> dp(n + 1, 0);
-        vector<int> nextDp(n + 1, 0);
+        vector<uint> dp(n + 1, 0);
+        vector<uint> nextDp(n + 1, 0);
         dp[n] = nextDp[n] = 1;
 
         for (int i = m - 1; i >= 0; i--) {
@@ -762,6 +850,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDistinct(_ s: String, _ t: String) -> Int {
+        let m = s.count, n = t.count
+        var dp = [Int](repeating: 0, count: n + 1)
+        var nextDp = [Int](repeating: 0, count: n + 1)
+        dp[n] = 1
+        nextDp[n] = 1
+
+        let sArr = Array(s)
+        let tArr = Array(t)
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                nextDp[j] = dp[j]
+                if sArr[i] == tArr[j] {
+                    let addend = dp[j + 1]
+                    if nextDp[j] > Int.max - addend {
+                        nextDp[j] = 0
+                    } else {
+                        nextDp[j] += addend
+                    }
+                }
+            }
+            dp = nextDp
+        }
+        
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -827,13 +947,13 @@ class Solution {
 public:
     int numDistinct(string s, string t) {
         int m = s.size(), n = t.size();
-        vector<int> dp(n + 1, 0);
+        vector<uint> dp(n + 1, 0);
         dp[n] = 1;
 
         for (int i = m - 1; i >= 0; i--) {
             int prev = 1;
             for (int j = n - 1; j >= 0; j--) {
-                int res = dp[j];
+                uint res = dp[j];
                 if (s[i] == t[j]) {
                     res += prev;
                 }
@@ -950,6 +1070,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDistinct(_ s: String, _ t: String) -> Int {
+        let m = s.count, n = t.count
+        var dp = [Int](repeating: 0, count: n + 1)
+        dp[n] = 1
+        let sArr = Array(s)
+        let tArr = Array(t)
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            var prev = 1
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                let base = dp[j]
+                var res = base
+                if sArr[i] == tArr[j] {
+                    if base > Int.max - prev {
+                        res = 0
+                    } else {
+                        res += prev
+                    }
+                }
+                prev = dp[j]
+                dp[j] = res
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/counting-bits.md b/articles/counting-bits.md
index ac8139aba..66b5db885 100644
--- a/articles/counting-bits.md
+++ b/articles/counting-bits.md
@@ -120,6 +120,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countBits(_ n: Int) -> [Int] {
+        var res = [Int]()
+        for num in 0...n {
+            var one = 0
+            for i in 0..<32 {
+                if num & (1 << i) != 0 {
+                    one += 1
+                }
+            }
+            res.append(one)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -246,6 +264,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countBits(_ n: Int) -> [Int] {
+        var res = [Int](repeating: 0, count: n + 1)
+        for i in 1..<(n + 1) {
+            var num = i
+            while num != 0 {
+                res[i] += 1
+                num &= (num - 1)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -338,6 +372,18 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countBits(_ n: Int) -> [Int] {
+        var res = [Int](repeating: 0, count: n + 1)
+        for num in 1..<(n + 1) {
+            res[num] = num.nonzeroBitCount
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -471,6 +517,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countBits(_ n: Int) -> [Int] {
+        var dp = [Int](repeating: 0, count: n + 1)
+        var offset = 1
+
+        for i in 1..<(n + 1) {
+            if offset * 2 == i {
+                offset = i
+            }
+            dp[i] = 1 + dp[i - offset]
+        }
+        return dp
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -570,6 +633,18 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countBits(_ n: Int) -> [Int] {
+        var dp = [Int](repeating: 0, count: n + 1)
+        for i in 0..<(n + 1) {
+            dp[i] = dp[i >> 1] + (i & 1)
+        }
+        return dp
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/course-schedule-ii.md b/articles/course-schedule-ii.md
index 7980e9e5e..6a3e85924 100644
--- a/articles/course-schedule-ii.md
+++ b/articles/course-schedule-ii.md
@@ -329,6 +329,51 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findOrder(_ numCourses: Int, _ prerequisites: [[Int]]) -> [Int] {
+        var prereq = [Int: [Int]]()
+        for c in 0..<numCourses {
+            prereq[c] = []
+        }
+        for pair in prerequisites {
+            prereq[pair[0]]!.append(pair[1])
+        }
+
+        var output = [Int]()
+        var visit = Set<Int>()
+        var cycle = Set<Int>()
+
+        func dfs(_ crs: Int) -> Bool {
+            if cycle.contains(crs) {
+                return false
+            }
+            if visit.contains(crs) {
+                return true
+            }
+
+            cycle.insert(crs)
+            for pre in prereq[crs]! {
+                if !dfs(pre) {
+                    return false
+                }
+            }
+            cycle.remove(crs)
+            visit.insert(crs)
+            output.append(crs)
+            return true
+        }
+
+        for c in 0..<numCourses {
+            if !dfs(c) {
+                return []
+            }
+        }
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -624,6 +669,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findOrder(_ numCourses: Int, _ prerequisites: [[Int]]) -> [Int] {
+        var indegree = Array(repeating: 0, count: numCourses)
+        var adj = Array(repeating: [Int](), count: numCourses)
+
+        for pair in prerequisites {
+            let src = pair[0]
+            let dst = pair[1]
+            indegree[dst] += 1
+            adj[src].append(dst)
+        }
+
+        var queue = Deque<Int>()
+        for n in 0..<numCourses {
+            if indegree[n] == 0 {
+                queue.append(n)
+            }
+        }
+
+        var finish = 0
+        var output = [Int]()
+        while !queue.isEmpty {
+            let node = queue.popFirst()!
+            output.append(node)
+            finish += 1
+            for nei in adj[node] {
+                indegree[nei] -= 1
+                if indegree[nei] == 0 {
+                    queue.append(nei)
+                }
+            }
+        }
+
+        return finish == numCourses ? output.reversed() : []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -898,6 +982,43 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findOrder(_ numCourses: Int, _ prerequisites: [[Int]]) -> [Int] {
+        var adj = Array(repeating: [Int](), count: numCourses)
+        var indegree = Array(repeating: 0, count: numCourses)
+
+        for pair in prerequisites {
+            let nxt = pair[0]
+            let pre = pair[1]
+            indegree[nxt] += 1
+            adj[pre].append(nxt)
+        }
+
+        var output = [Int]()
+
+        func dfs(_ node: Int) {
+            output.append(node)
+            indegree[node] -= 1
+            for nei in adj[node] {
+                indegree[nei] -= 1
+                if indegree[nei] == 0 {
+                    dfs(nei)
+                }
+            }
+        }
+
+        for i in 0..<numCourses {
+            if indegree[i] == 0 {
+                dfs(i)
+            }
+        }
+
+        return output.count == numCourses ? output : []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/course-schedule.md b/articles/course-schedule.md
index b499babdf..d57ce12c1 100644
--- a/articles/course-schedule.md
+++ b/articles/course-schedule.md
@@ -310,6 +310,51 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canFinish(_ numCourses: Int, _ prerequisites: [[Int]]) -> Bool {
+        // Map each course to its prerequisites
+        var preMap = [Int: [Int]]()
+        for i in 0..<numCourses {
+            preMap[i] = []
+        }
+        for pair in prerequisites {
+            preMap[pair[0]]!.append(pair[1])
+        }
+
+        // Store all courses along the current DFS path
+        var visiting = Set<Int>()
+
+        func dfs(_ crs: Int) -> Bool {
+            if visiting.contains(crs) {
+                // Cycle detected
+                return false
+            }
+            if preMap[crs]!.isEmpty {
+                return true
+            }
+
+            visiting.insert(crs)
+            for pre in preMap[crs]! {
+                if !dfs(pre) {
+                    return false
+                }
+            }
+            visiting.remove(crs)
+            preMap[crs] = []
+            return true
+        }
+
+        for c in 0..<numCourses {
+            if !dfs(c) {
+                return false
+            }
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -575,6 +620,43 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canFinish(_ numCourses: Int, _ prerequisites: [[Int]]) -> Bool {
+        var indegree = Array(repeating: 0, count: numCourses)
+        var adj = Array(repeating: [Int](), count: numCourses)
+
+        for pair in prerequisites {
+            let src = pair[0]
+            let dst = pair[1]
+            indegree[dst] += 1
+            adj[src].append(dst)
+        }
+
+        var queue = Deque<Int>()
+        for n in 0..<numCourses {
+            if indegree[n] == 0 {
+                queue.append(n)
+            }
+        }
+
+        var finish = 0
+        while !queue.isEmpty {
+            let node = queue.popFirst()!
+            finish += 1
+            for nei in adj[node] {
+                indegree[nei] -= 1
+                if indegree[nei] == 0 {
+                    queue.append(nei)
+                }
+            }
+        }
+
+        return finish == numCourses
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/daily-temperatures.md b/articles/daily-temperatures.md
index 786847104..f004aac40 100644
--- a/articles/daily-temperatures.md
+++ b/articles/daily-temperatures.md
@@ -177,12 +177,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func dailyTemperatures(_ temperatures: [Int]) -> [Int] {
+        let n = temperatures.count
+        var res = [Int]()
+
+        for i in 0..<n {
+            var count = 1
+            var j = i + 1
+            while j < n {
+                if temperatures[j] > temperatures[i] {
+                    break
+                }
+                j += 1
+                count += 1
+            }
+            count = (j == n) ? 0 : count
+            res.append(count)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n ^ 2)$
-* Space complexity: $O(1)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output array.
 
 ---
 
@@ -323,6 +349,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func dailyTemperatures(_ temperatures: [Int]) -> [Int] {
+        var res = [Int](repeating: 0, count: temperatures.count)
+        var stack = [(Int, Int)]() // Pair: (temperature, index)
+
+        for (i, t) in temperatures.enumerated() {
+            while !stack.isEmpty && t > stack.last!.0 {
+                let (stackT, stackInd) = stack.removeLast()
+                res[stackInd] = i - stackInd
+            }
+            stack.append((t, i))
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -508,9 +552,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func dailyTemperatures(_ temperatures: [Int]) -> [Int] {
+        let n = temperatures.count
+        var res = [Int](repeating: 0, count: n)
+
+        for i in stride(from: n - 2, through: 0, by: -1) {
+            var j = i + 1
+            while j < n && temperatures[j] <= temperatures[i] {
+                if res[j] == 0 {
+                    j = n
+                    break
+                }
+                j += res[j]
+            }
+
+            if j < n {
+                res[i] = j - i
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n)$
-* Space complexity: $O(1)$
\ No newline at end of file
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output array.
\ No newline at end of file
diff --git a/articles/decode-ways.md b/articles/decode-ways.md
index bfda19321..c735d1d3f 100644
--- a/articles/decode-ways.md
+++ b/articles/decode-ways.md
@@ -163,6 +163,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDecodings(_ s: String) -> Int {
+        let chars = Array(s)
+        
+        func dfs(_ i: Int) -> Int {
+            if i == chars.count {
+                return 1
+            }
+            if chars[i] == "0" {
+                return 0
+            }
+
+            var res = dfs(i + 1)
+            if i < chars.count - 1 {
+                if chars[i] == "1" || (chars[i] == "2" && chars[i + 1] < "7") {
+                    res += dfs(i + 2)
+                }
+            }
+
+            return res
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -375,6 +403,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDecodings(_ s: String) -> Int {
+        let chars = Array(s)
+        var dp = [Int: Int]()
+        dp[chars.count] = 1
+
+        func dfs(_ i: Int) -> Int {
+            if let cached = dp[i] {
+                return cached
+            }
+            if chars[i] == "0" {
+                return 0
+            }
+
+            var res = dfs(i + 1)
+            if i + 1 < chars.count, 
+               chars[i] == "1" || (chars[i] == "2" && "0123456".contains(chars[i + 1])) {
+                res += dfs(i + 2)
+            }
+            dp[i] = res
+            return res
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -533,6 +590,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDecodings(_ s: String) -> Int {
+        let chars = Array(s)
+        var dp = [Int: Int]()
+        dp[chars.count] = 1
+
+        for i in stride(from: chars.count - 1, through: 0, by: -1) {
+            if chars[i] == "0" {
+                dp[i] = 0
+            } else {
+                dp[i] = dp[i + 1] ?? 0
+            }
+
+            if i + 1 < chars.count, 
+               chars[i] == "1" || (chars[i] == "2" && "0123456".contains(chars[i + 1])) {
+                dp[i]! += dp[i + 2] ?? 0
+            }
+        }
+        return dp[0] ?? 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -711,6 +792,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func numDecodings(_ s: String) -> Int {
+        let chars = Array(s)
+        var dp = 0, dp1 = 1, dp2 = 0
+
+        for i in stride(from: chars.count - 1, through: 0, by: -1) {
+            if chars[i] == "0" {
+                dp = 0
+            } else {
+                dp = dp1
+            }
+
+            if i + 1 < chars.count, 
+               chars[i] == "1" || (chars[i] == "2" && "0123456".contains(chars[i + 1])) {
+                dp += dp2
+            }
+            (dp, dp1, dp2) = (0, dp, dp1)
+        }
+        return dp1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/depth-of-binary-tree.md b/articles/depth-of-binary-tree.md
index efd76b64d..88a35751d 100644
--- a/articles/depth-of-binary-tree.md
+++ b/articles/depth-of-binary-tree.md
@@ -171,6 +171,30 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func maxDepth(_ root: TreeNode?) -> Int {
+        guard let root = root else { return 0 }
+        return 1 + max(maxDepth(root.left), maxDepth(root.right))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -440,6 +464,41 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func maxDepth(_ root: TreeNode?) -> Int {
+        var stack: [(TreeNode?, Int)] = [(root, 1)]
+        var res = 0
+
+        while !stack.isEmpty {
+            let (node, depth) = stack.removeLast()
+
+            if let node = node {
+                res = max(res, depth)
+                stack.append((node.left, depth + 1))
+                stack.append((node.right, depth + 1))
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -723,6 +782,47 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func maxDepth(_ root: TreeNode?) -> Int {
+        var queue = Deque<TreeNode>()
+        if let root = root {
+            queue.append(root)
+        }
+
+        var level = 0
+        while !queue.isEmpty {
+            for _ in 0..<queue.count {
+                let node = queue.removeFirst()
+                if let left = node.left {
+                    queue.append(left)
+                }
+                if let right = node.right {
+                    queue.append(right)
+                }
+            }
+            level += 1
+        }
+        return level
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/design-twitter-feed.md b/articles/design-twitter-feed.md
index 56d7a5848..75eade212 100644
--- a/articles/design-twitter-feed.md
+++ b/articles/design-twitter-feed.md
@@ -321,6 +321,51 @@ class Twitter {
 }
 ```
 
+```swift
+class Twitter {
+    private var time: Int
+    private var followMap: [Int: Set<Int>]
+    private var tweetMap: [Int: [(Int, Int)]]
+
+    init() {
+        self.time = 0
+        self.followMap = [:]
+        self.tweetMap = [:]
+    }
+
+    func postTweet(_ userId: Int, _ tweetId: Int) {
+        if tweetMap[userId] == nil {
+            tweetMap[userId] = []
+        }
+        tweetMap[userId]!.append((time, tweetId))
+        time += 1
+    }
+
+    func getNewsFeed(_ userId: Int) -> [Int] {
+        var feed = tweetMap[userId] ?? []
+        if let followees = followMap[userId] {
+            for followeeId in followees {
+                if let tweets = tweetMap[followeeId] {
+                    feed.append(contentsOf: tweets)
+                }
+            }
+        }
+        feed.sort { $0.0 > $1.0 }
+        return feed.prefix(10).map { $0.1 }
+    }
+
+    func follow(_ followerId: Int, _ followeeId: Int) {
+        if followerId != followeeId {
+            followMap[followerId, default: Set()].insert(followeeId)
+        }
+    }
+
+    func unfollow(_ followerId: Int, _ followeeId: Int) {
+        followMap[followerId]?.remove(followeeId)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -769,6 +814,84 @@ class Twitter {
 }
 ```
 
+```swift
+class Twitter {
+    private var count: Int
+    private var tweetMap: [Int: [(Int, Int)]]  // userId -> list of (count, tweetId)
+    private var followMap: [Int: Set<Int>]     // userId -> set of followeeId
+    
+    init() {
+        self.count = 0
+        self.tweetMap = [:]
+        self.followMap = [:]
+    }
+    
+    func postTweet(_ userId: Int, _ tweetId: Int) {
+        tweetMap[userId, default: []].append((count, tweetId))
+        count -= 1
+    }
+    
+    func getNewsFeed(_ userId: Int) -> [Int] {
+        var res = [Int]()
+        var minHeap = Heap<Item>()
+        
+        followMap[userId, default: Set()].insert(userId)
+        if let followees = followMap[userId] {
+            for followee in followees {
+                if let tweets = tweetMap[followee], !tweets.isEmpty {
+                    let index = tweets.count - 1
+                    let (cnt, tweetId) = tweets[index]
+                    minHeap.insert(
+                        Item(
+                            count: cnt, tweetId: tweetId,
+                            followeeId: followee, index: index - 1
+                        )
+                    )
+                }
+            }
+        }
+        
+        while !minHeap.isEmpty && res.count < 10 {
+            let entry = minHeap.popMin()!
+            res.append(entry.tweetId)
+            if entry.index >= 0, let tweets = tweetMap[entry.followeeId] {
+                let (cnt, tweetId) = tweets[entry.index]
+                minHeap.insert(
+                    Item(
+                        count: cnt, tweetId: tweetId,
+                        followeeId: entry.followeeId, index: entry.index - 1
+                    )
+                )
+            }
+        }
+        return res
+    }
+    
+    func follow(_ followerId: Int, _ followeeId: Int) {
+        followMap[followerId, default: Set()].insert(followeeId)
+    }
+    
+    func unfollow(_ followerId: Int, _ followeeId: Int) {
+        followMap[followerId]?.remove(followeeId)
+    }
+}
+
+struct Item: Comparable {
+    let count: Int
+    let tweetId: Int
+    let followeeId: Int
+    let index: Int
+    
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.count < rhs.count
+    }
+    
+    static func == (lhs: Item, rhs: Item) -> Bool {
+        return lhs.count == rhs.count
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1425,6 +1548,112 @@ class Twitter {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let count: Int
+    let tweetId: Int
+    let followeeId: Int
+    let index: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.count < rhs.count
+    }
+
+    static func == (lhs: Item, rhs: Item) -> Bool {
+        return lhs.count == rhs.count &&
+               lhs.tweetId == rhs.tweetId &&
+               lhs.followeeId == rhs.followeeId &&
+               lhs.index == rhs.index
+    }
+}
+
+class Twitter {
+    private var count: Int
+    private var tweetMap: [Int: [(Int, Int)]] // userId -> list of (count, tweetId)
+    private var followMap: [Int: Set<Int>]    // userId -> set of followeeId
+
+    init() {
+        self.count = 0
+        self.tweetMap = [:]
+        self.followMap = [:]
+    }
+
+    func postTweet(_ userId: Int, _ tweetId: Int) {
+        tweetMap[userId, default: []].append((count, tweetId))
+        if tweetMap[userId]!.count > 10 {
+            tweetMap[userId]!.removeFirst()
+        }
+        count -= 1
+    }
+
+    func getNewsFeed(_ userId: Int) -> [Int] {
+        var res = [Int]()
+        var minHeap = Heap<Item>()
+        followMap[userId, default: Set()].insert(userId)
+
+        if followMap[userId]!.count >= 10 {
+            var maxHeap = Heap<Item>()
+            for followeeId in followMap[userId]! {
+                if let tweets = tweetMap[followeeId], !tweets.isEmpty {
+                    let index = tweets.count - 1
+                    let (cnt, tweetId) = tweets[index]
+                    maxHeap.insert(
+                        Item(
+                            count: cnt, tweetId: tweetId,
+                            followeeId: followeeId, index: index - 1
+                        )
+                    )
+                    if maxHeap.count > 10 {
+                        maxHeap.removeMax()
+                    }
+                }
+            }
+            while !maxHeap.isEmpty {
+                let item = maxHeap.popMax()!
+                minHeap.insert(item)
+            }
+        } else {
+            for followeeId in followMap[userId]! {
+                if let tweets = tweetMap[followeeId], !tweets.isEmpty {
+                    let index = tweets.count - 1
+                    let (cnt, tweetId) = tweets[index]
+                    minHeap.insert(
+                        Item(
+                            count: cnt, tweetId: tweetId,
+                            followeeId: followeeId, index: index - 1
+                        )
+                    )
+                }
+            }
+        }
+
+        while !minHeap.isEmpty && res.count < 10 {
+            let item = minHeap.popMin()!
+            res.append(item.tweetId)
+            if item.index >= 0, let tweets = tweetMap[item.followeeId] {
+                let (cnt, tweetId) = tweets[item.index]
+                minHeap.insert(
+                    Item(
+                        count: cnt, tweetId: tweetId,
+                        followeeId: item.followeeId, index: item.index - 1
+                    )
+                )
+            }
+        }
+
+        return res
+    }
+
+    func follow(_ followerId: Int, _ followeeId: Int) {
+        followMap[followerId, default: Set()].insert(followeeId)
+    }
+
+    func unfollow(_ followerId: Int, _ followeeId: Int) {
+        followMap[followerId]?.remove(followeeId)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/design-word-search-data-structure.md b/articles/design-word-search-data-structure.md
index 501e42785..033096234 100644
--- a/articles/design-word-search-data-structure.md
+++ b/articles/design-word-search-data-structure.md
@@ -222,6 +222,42 @@ class WordDictionary {
 }
 ```
 
+```swift
+class WordDictionary {
+    private var store: [String]
+
+    init() {
+        self.store = []
+    }
+
+    func addWord(_ word: String) {
+        store.append(word)
+    }
+
+    func search(_ word: String) -> Bool {
+        for w in store {
+            if w.count != word.count {
+                continue
+            }
+            var i = 0
+            let wArray = Array(w)
+            let wordArray = Array(word)
+            while i < wArray.count {
+                if wArray[i] == wordArray[i] || wordArray[i] == "." {
+                    i += 1
+                } else {
+                    break
+                }
+            }
+            if i == wArray.count {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -627,6 +663,64 @@ class WordDictionary {
 }
 ```
 
+```swift
+class TrieNode {
+    var children: [Character: TrieNode]
+    var word: Bool
+
+    init() {
+        self.children = [:]
+        self.word = false
+    }
+}
+
+class WordDictionary {
+    private let root: TrieNode
+
+    init() {
+        self.root = TrieNode()
+    }
+
+    func addWord(_ word: String) {
+        var cur = root
+        for c in word {
+            if cur.children[c] == nil {
+                cur.children[c] = TrieNode()
+            }
+            cur = cur.children[c]!
+        }
+        cur.word = true
+    }
+
+    func search(_ word: String) -> Bool {
+        func dfs(_ j: Int, _ root: TrieNode) -> Bool {
+            var cur = root
+            let wordArray = Array(word)
+
+            for i in j..<wordArray.count {
+                let c = wordArray[i]
+                if c == "." {
+                    for child in cur.children.values {
+                        if dfs(i + 1, child) {
+                            return true
+                        }
+                    }
+                    return false
+                } else {
+                    if cur.children[c] == nil {
+                        return false
+                    }
+                    cur = cur.children[c]!
+                }
+            }
+            return cur.word
+        }
+
+        return dfs(0, root)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/duplicate-integer.md b/articles/duplicate-integer.md
index c7b5e21f2..882486892 100644
--- a/articles/duplicate-integer.md
+++ b/articles/duplicate-integer.md
@@ -105,11 +105,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hasDuplicate(_ nums: [Int]) -> Bool {
+        for i in 0..<nums.count {
+            for j in (i + 1)..<nums.count {
+                if nums[i] == nums[j] {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
-* Time complexity: $O(n^2)$
+* Time complexity: $O(n ^ 2)$
 * Space complexity: $O(1)$
 
 ---
@@ -215,6 +230,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hasDuplicate(_ nums: [Int]) -> Bool {
+        var nums = nums.sorted()
+        for i in 1..<nums.count {
+            if nums[i] == nums[i - 1] {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -332,6 +361,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hasDuplicate(_ nums: [Int]) -> Bool {
+        var seen = Set<Int>()
+        for num in nums {
+            if seen.contains(num) {
+                return true
+            }
+            seen.insert(num)
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -406,6 +450,14 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hasDuplicate(_ nums: [Int]) -> Bool {
+        return Set(nums).count < nums.count
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/eating-bananas.md b/articles/eating-bananas.md
index bf00f6c04..4acd82fb0 100644
--- a/articles/eating-bananas.md
+++ b/articles/eating-bananas.md
@@ -137,6 +137,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minEatingSpeed(_ piles: [Int], _ h: Int) -> Int {
+        var speed = 1
+        
+        while true {
+            var totalTime = 0
+            for pile in piles {
+                totalTime += Int(ceil(Double(pile) / Double(speed)))
+            }
+            
+            if totalTime <= h {
+                return speed
+            }
+            speed += 1
+        }
+        return speed
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -338,6 +359,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minEatingSpeed(_ piles: [Int], _ h: Int) -> Int {
+        var l = 1, r = piles.max()!
+        var res = r
+
+        while l <= r {
+            let k = (l + r) / 2
+
+            var totalTime = 0
+            for p in piles {
+                totalTime += Int(ceil(Double(p) / Double(k)))
+            }
+
+            if totalTime <= h {
+                res = k
+                r = k - 1
+            } else {
+                l = k + 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/edit-distance.md b/articles/edit-distance.md
index a116df5c7..7c4b6bfeb 100644
--- a/articles/edit-distance.md
+++ b/articles/edit-distance.md
@@ -169,6 +169,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minDistance(_ word1: String, _ word2: String) -> Int {
+        let m = word1.count, n = word2.count
+        let word1Array = Array(word1), word2Array = Array(word2)
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == m { return n - j }
+            if j == n { return m - i }
+            if word1Array[i] == word2Array[j] {
+                return dfs(i + 1, j + 1)
+            }
+            let res = min(dfs(i + 1, j), dfs(i, j + 1))
+            return min(res, dfs(i + 1, j + 1)) + 1
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -403,6 +424,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minDistance(_ word1: String, _ word2: String) -> Int {
+        let m = word1.count, n = word2.count
+        let word1Array = Array(word1), word2Array = Array(word2)
+        var dp = [[Int?]](repeating: [Int?](repeating: nil, count: n + 1), count: m + 1)
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == m { return n - j }
+            if j == n { return m - i }
+            if let val = dp[i][j] { return val }
+
+            if word1Array[i] == word2Array[j] {
+                dp[i][j] = dfs(i + 1, j + 1)
+            } else {
+                let res = min(dfs(i + 1, j), dfs(i, j + 1), dfs(i + 1, j + 1)) + 1
+                dp[i][j] = res
+            }
+            return dp[i][j]!
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -624,6 +671,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minDistance(_ word1: String, _ word2: String) -> Int {
+        let m = word1.count, n = word2.count
+        let word1Array = Array(word1), word2Array = Array(word2)
+        var dp = [[Int]](repeating: [Int](repeating: Int.max, count: n + 1), count: m + 1)
+
+        for j in 0...n {
+            dp[m][j] = n - j
+        }
+        for i in 0...m {
+            dp[i][n] = m - i
+        }
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                if word1Array[i] == word2Array[j] {
+                    dp[i][j] = dp[i + 1][j + 1]
+                } else {
+                    dp[i][j] = 1 + min(dp[i + 1][j], dp[i][j + 1], dp[i + 1][j + 1])
+                }
+            }
+        }
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -890,6 +965,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minDistance(_ word1: String, _ word2: String) -> Int {
+        var m = word1.count, n = word2.count
+        var word1Array = Array(word1), word2Array = Array(word2)
+        
+        if m < n {
+            swap(&m, &n)
+            swap(&word1Array, &word2Array)
+        }
+
+        var dp = [Int](repeating: 0, count: n + 1)
+        var nextDp = [Int](repeating: 0, count: n + 1)
+
+        for j in 0...n {
+            dp[j] = n - j
+        }
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            nextDp[n] = m - i
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                if word1Array[i] == word2Array[j] {
+                    nextDp[j] = dp[j + 1]
+                } else {
+                    nextDp[j] = 1 + min(dp[j], nextDp[j + 1], dp[j + 1])
+                }
+            }
+            dp = nextDp
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1134,6 +1244,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minDistance(_ word1: String, _ word2: String) -> Int {
+        var m = word1.count, n = word2.count
+        var word1Array = Array(word1), word2Array = Array(word2)
+        
+        if m < n {
+            swap(&m, &n)
+            swap(&word1Array, &word2Array)
+        }
+
+        var dp = (0...n).map { n - $0 }
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            var nextDp = dp[n]
+            dp[n] = m - i
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                let temp = dp[j]
+                if word1Array[i] == word2Array[j] {
+                    dp[j] = nextDp
+                } else {
+                    dp[j] = 1 + min(dp[j], dp[j + 1], nextDp)
+                }
+                nextDp = temp
+            }
+        }
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/evaluate-reverse-polish-notation.md b/articles/evaluate-reverse-polish-notation.md
index 9c3520b02..3ad96eff8 100644
--- a/articles/evaluate-reverse-polish-notation.md
+++ b/articles/evaluate-reverse-polish-notation.md
@@ -216,6 +216,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func evalRPN(_ tokens: [String]) -> Int {
+        var tokens = tokens
+
+        while tokens.count > 1 {
+            for i in 0..<tokens.count {
+                if "+-*/".contains(tokens[i]) {
+                    let a = Int(tokens[i-2])!
+                    let b = Int(tokens[i-1])!
+                    var result = 0
+                    
+                    if tokens[i] == "+" {
+                        result = a + b
+                    } else if tokens[i] == "-" {
+                        result = a - b
+                    } else if tokens[i] == "*" {
+                        result = a * b
+                    } else if tokens[i] == "/" {
+                        result = Int(a / b)
+                    }
+                    
+                    tokens = Array(tokens[0..<(i-2)]) + [String(result)] + Array(tokens[(i+1)...])
+                    break
+                }
+            }
+        }
+
+        return Int(tokens[0])!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -590,6 +623,64 @@ class Solution {
 }
 ```
 
+```swift
+class DoublyLinkedList {
+    var val: String
+    var next: DoublyLinkedList?
+    var prev: DoublyLinkedList?
+
+    init(val: String, next: DoublyLinkedList? = nil, prev: DoublyLinkedList? = nil) {
+        self.val = val
+        self.next = next
+        self.prev = prev
+    }
+}
+
+class Solution {
+    func evalRPN(_ tokens: [String]) -> Int {
+        var head: DoublyLinkedList? = DoublyLinkedList(val: tokens[0])
+        var curr = head
+
+        for i in 1..<tokens.count {
+            curr!.next = DoublyLinkedList(val: tokens[i], prev: curr)
+            curr = curr!.next
+        }
+
+        var ans = 0
+
+        while head != nil {
+            if "+-*/".contains(head!.val) {
+                let l = Int(head!.prev!.prev!.val)!
+                let r = Int(head!.prev!.val)!
+                var res: Int
+
+                if head!.val == "+" {
+                    res = l + r
+                } else if head!.val == "-" {
+                    res = l - r
+                } else if head!.val == "*" {
+                    res = l * r
+                } else {
+                    res = l / r
+                }
+
+                head!.val = String(res)
+                head!.prev = head!.prev!.prev!.prev
+
+                if head!.prev != nil {
+                    head!.prev!.next = head
+                }
+            }
+
+            ans = Int(head!.val)!
+            head = head!.next
+        }
+
+        return ans
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -824,6 +915,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func evalRPN(_ tokens: [String]) -> Int {
+        var tokens = tokens
+        
+        func dfs() -> Int {
+            let token = tokens.removeLast()
+            if let num = Int(token) {
+                return num
+            }
+
+            let right = dfs()
+            let left = dfs()
+
+            switch token {
+                case "+": return left + right
+                case "-": return left - right
+                case "*": return left * right
+                case "/": return left / right
+                default: return 0
+            }
+        }
+        
+        return dfs()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1042,6 +1161,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func evalRPN(_ tokens: [String]) -> Int {
+        var stack = [Int]()
+
+        for c in tokens {
+            switch c {
+                case "+":
+                    stack.append(stack.removeLast() + stack.removeLast())
+                case "-":
+                    let a = stack.removeLast()
+                    let b = stack.removeLast()
+                    stack.append(b - a)
+                case "*":
+                    stack.append(stack.removeLast() * stack.removeLast())
+                case "/":
+                    let a = stack.removeLast()
+                    let b = stack.removeLast()
+                    stack.append(b / a)
+                default:
+                    stack.append(Int(c)!)
+            }
+        }
+        return stack[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/find-duplicate-integer.md b/articles/find-duplicate-integer.md
index 46542d9b6..ef3317436 100644
--- a/articles/find-duplicate-integer.md
+++ b/articles/find-duplicate-integer.md
@@ -99,6 +99,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        var nums = nums.sorted()
+        for i in 0..<nums.count - 1 {
+            if nums[i] == nums[i + 1] {
+                return nums[i]
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -216,6 +230,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        var seen = Set<Int>()
+        for num in nums {
+            if seen.contains(num) {
+                return num
+            }
+            seen.insert(num)
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -333,6 +362,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        var seen = [Int](repeating: 0, count: nums.count)
+        for num in nums {
+            if seen[num - 1] == 1 {
+                return num
+            }
+            seen[num - 1] = 1
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -457,6 +501,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        var nums = nums
+        for num in nums {
+            let idx = abs(num) - 1
+            if nums[idx] < 0 {
+                return abs(num)
+            }
+            nums[idx] *= -1
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -656,6 +716,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var low = 1, high = n - 1
+
+        while low < high {
+            let mid = low + (high - low) / 2
+            let lessOrEqual = nums.filter { $0 <= mid }.count
+
+            if lessOrEqual <= mid {
+                low = mid + 1
+            } else {
+                high = mid
+            }
+        }
+        return low
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -866,6 +947,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var res = 0
+
+        for b in 0..<32 {
+            var x = 0, y = 0
+            let mask = 1 << b
+
+            for num in nums {
+                if num & mask != 0 {
+                    x += 1
+                }
+            }
+
+            for num in 1..<n {
+                if num & mask != 0 {
+                    y += 1
+                }
+            }
+
+            if x > y {
+                res |= mask
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1052,6 +1164,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findDuplicate(_ nums: [Int]) -> Int {
+        var slow = 0, fast = 0
+
+        while true {
+            slow = nums[slow]
+            fast = nums[nums[fast]]
+            if slow == fast {
+                break
+            }
+        }
+
+        var slow2 = 0
+        while true {
+            slow = nums[slow]
+            slow2 = nums[slow2]
+            if slow == slow2 {
+                return slow
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/find-median-in-a-data-stream.md b/articles/find-median-in-a-data-stream.md
index ab246b370..ad27aa749 100644
--- a/articles/find-median-in-a-data-stream.md
+++ b/articles/find-median-in-a-data-stream.md
@@ -162,6 +162,30 @@ class MedianFinder() {
 }
 ```
 
+```swift
+class MedianFinder {
+    private var data: [Int]
+
+    init() {
+        self.data = []
+    }
+
+    func addNum(_ num: Int) {
+        data.append(num)
+    }
+
+    func findMedian() -> Double {
+        data.sort()
+        let n = data.count
+        if n % 2 == 1 {
+            return Double(data[n / 2])
+        } else {
+            return (Double(data[n / 2]) + Double(data[n / 2 - 1])) / 2.0
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -447,6 +471,47 @@ class MedianFinder() {
 }
 ```
 
+```swift
+class MedianFinder {
+    // two heaps, large, small, minheap, maxheap
+    // heaps should be equal size
+    private var small: Heap<Int>
+    private var large: Heap<Int>
+
+    init() {
+        self.small = Heap<Int>()
+        self.large = Heap<Int>()
+    }
+
+    func addNum(_ num: Int) {
+        if let top = large.min, num > top {
+            large.insert(num)
+        } else {
+            small.insert(num)
+        }
+        if small.count > large.count + 1 {
+            if let val = small.popMax() {
+                large.insert(val)
+            }
+        }
+        if large.count > small.count + 1 {
+            if let val = large.popMin() {
+                small.insert(val)
+            }
+        }
+    }
+
+    func findMedian() -> Double {
+        if small.count > large.count {
+            return Double(small.max!)
+        } else if large.count > small.count {
+            return Double(large.min!)
+        }
+        return (Double(small.max!) + Double(large.min!)) / 2.0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/find-minimum-in-rotated-sorted-array.md b/articles/find-minimum-in-rotated-sorted-array.md
index 3c4c59be9..9443959d2 100644
--- a/articles/find-minimum-in-rotated-sorted-array.md
+++ b/articles/find-minimum-in-rotated-sorted-array.md
@@ -65,6 +65,14 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findMin(_ nums: [Int]) -> Int {
+        return nums.min()!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -261,6 +269,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findMin(_ nums: [Int]) -> Int {
+        var res = nums[0]
+        var l = 0, r = nums.count - 1
+
+        while l <= r {
+            if nums[l] < nums[r] {
+                res = min(res, nums[l])
+                break
+            }
+
+            let m = (l + r) / 2
+            res = min(res, nums[m])
+
+            if nums[m] >= nums[l] {
+                l = m + 1
+            } else {
+                r = m - 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -396,6 +430,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findMin(_ nums: [Int]) -> Int {
+        var l = 0, r = nums.count - 1
+        while l < r {
+            let m = l + (r - l) / 2
+            if nums[m] < nums[r] {
+                r = m
+            } else {
+                l = m + 1
+            }
+        }
+        return nums[l]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/find-target-in-rotated-sorted-array.md b/articles/find-target-in-rotated-sorted-array.md
index 2e6dd37e5..b406838bb 100644
--- a/articles/find-target-in-rotated-sorted-array.md
+++ b/articles/find-target-in-rotated-sorted-array.md
@@ -93,6 +93,19 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        for i in 0..<nums.count {
+            if nums[i] == target {
+                return i
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -392,6 +405,47 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        var l = 0, r = nums.count - 1
+
+        while l < r {
+            let m = (l + r) / 2
+            if nums[m] > nums[r] {
+                l = m + 1
+            } else {
+                r = m
+            }
+        }
+
+        let pivot = l
+
+        func binarySearch(_ left: Int, _ right: Int) -> Int {
+            var l = left, r = right
+            while l <= r {
+                let mid = (l + r) / 2
+                if nums[mid] == target {
+                    return mid
+                } else if nums[mid] < target {
+                    l = mid + 1
+                } else {
+                    r = mid - 1
+                }
+            }
+            return -1
+        }
+
+        let result = binarySearch(0, pivot - 1)
+        if result != -1 {
+            return result
+        }
+
+        return binarySearch(pivot, nums.count - 1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -681,6 +735,46 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        var l = 0, r = nums.count - 1
+
+        while l < r {
+            let m = (l + r) / 2
+            if nums[m] > nums[r] {
+                l = m + 1
+            } else {
+                r = m
+            }
+        }
+
+        let pivot = l
+        l = 0
+        r = nums.count - 1
+
+        if target >= nums[pivot] && target <= nums[r] {
+            l = pivot
+        } else {
+            r = pivot - 1
+        }
+
+        while l <= r {
+            let m = (l + r) / 2
+            if nums[m] == target {
+                return m
+            } else if nums[m] < target {
+                l = m + 1
+            } else {
+                r = m - 1
+            }
+        }
+
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -908,6 +1002,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        var l = 0, r = nums.count - 1
+
+        while l <= r {
+            let mid = (l + r) / 2
+            if target == nums[mid] {
+                return mid
+            }
+
+            if nums[l] <= nums[mid] {
+                if target > nums[mid] || target < nums[l] {
+                    l = mid + 1
+                } else {
+                    r = mid - 1
+                }
+            } else {
+                if target < nums[mid] || target > nums[r] {
+                    r = mid - 1
+                } else {
+                    l = mid + 1
+                }
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/foreign-dictionary.md b/articles/foreign-dictionary.md
index f1353b74a..1bb32e486 100644
--- a/articles/foreign-dictionary.md
+++ b/articles/foreign-dictionary.md
@@ -405,6 +405,65 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func foreignDictionary(_ words: [String]) -> String {
+        var adj = [Character: Set<Character>]()
+        for word in words {
+            for char in word {
+                if adj[char] == nil {
+                    adj[char] = Set<Character>()
+                }
+            }
+        }
+        
+        for i in 0..<words.count - 1 {
+            let w1 = words[i]
+            let w2 = words[i + 1]
+            let minLen = min(w1.count, w2.count)
+            if w1.count > w2.count && String(w1.prefix(minLen)) == String(w2.prefix(minLen)) {
+                return ""
+            }
+            for j in 0..<minLen {
+                let index1 = w1.index(w1.startIndex, offsetBy: j)
+                let index2 = w2.index(w2.startIndex, offsetBy: j)
+                if w1[index1] != w2[index2] {
+                    adj[w1[index1]]?.insert(w2[index2])
+                    break
+                }
+            }
+        }
+        
+        var visited = [Character: Bool]()
+        var res = [Character]()
+        
+        func dfs(_ char: Character) -> Bool {
+            if let flag = visited[char] {
+                return flag
+            }
+            visited[char] = true
+            for neigh in adj[char]! {
+                if dfs(neigh) {
+                    return true
+                }
+            }
+            visited[char] = false
+            res.append(char)
+            return false
+        }
+        
+        for char in adj.keys {
+            if dfs(char) {
+                return ""
+            }
+        }
+        
+        res.reverse()
+        return String(res)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -823,6 +882,69 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func foreignDictionary(_ words: [String]) -> String {
+        var adj = [Character: Set<Character>]()
+        for word in words {
+            for char in word {
+                adj[char] = Set<Character>()
+            }
+        }
+        
+        var indegree = [Character: Int]()
+        for key in adj.keys {
+            indegree[key] = 0
+        }
+        
+        for i in 0..<words.count - 1 {
+            let w1 = words[i]
+            let w2 = words[i + 1]
+            let minLen = min(w1.count, w2.count)
+            if w1.count > w2.count && String(w1.prefix(minLen)) == String(w2.prefix(minLen)) {
+                return ""
+            }
+            let w1Arr = Array(w1)
+            let w2Arr = Array(w2)
+            for j in 0..<minLen {
+                if w1Arr[j] != w2Arr[j] {
+                    if !adj[w1Arr[j]]!.contains(w2Arr[j]) {
+                        adj[w1Arr[j]]!.insert(w2Arr[j])
+                        indegree[w2Arr[j]]! += 1
+                    }
+                    break
+                }
+            }
+        }
+        
+        var q = Deque<Character>()
+        for (c, deg) in indegree {
+            if deg == 0 {
+                q.append(c)
+            }
+        }
+        
+        var res = [Character]()
+        while !q.isEmpty {
+            let char = q.removeFirst()
+            res.append(char)
+            for neighbor in adj[char]! {
+                indegree[neighbor]! -= 1
+                if indegree[neighbor]! == 0 {
+                    q.append(neighbor)
+                }
+            }
+        }
+        
+        if res.count != indegree.count {
+            return ""
+        }
+        
+        return String(res)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/gas-station.md b/articles/gas-station.md
index cedbf31c2..9e779b1d8 100644
--- a/articles/gas-station.md
+++ b/articles/gas-station.md
@@ -11,6 +11,7 @@ class Solution:
             tank = gas[i] - cost[i]
             if tank < 0:
                 continue
+
             j = (i + 1) % n
             while j != i:
                 tank += gas[j]
@@ -19,6 +20,7 @@ class Solution:
                     break
                 j += 1
                 j %= n
+
             if j == i:
                 return i
         return -1
@@ -32,12 +34,14 @@ public class Solution {
         for (int i = 0; i < n; i++) {
             int tank = gas[i] - cost[i];
             if (tank < 0) continue;
+
             int j = (i + 1) % n;
             while (j != i) {
                 tank += gas[j] - cost[j];
                 if (tank < 0) break;
                 j = (j + 1) % n;
             }
+
             if (j == i) return i;
         }
         return -1;
@@ -54,12 +58,14 @@ public:
         for (int i = 0; i < n; i++) {
             int tank = gas[i] - cost[i];
             if (tank < 0) continue;
+
             int j = (i + 1) % n;
             while (j != i) {
                 tank += gas[j] - cost[j];
                 if (tank < 0) break;
                 j = (j + 1) % n;
             }
+
             if (j == i) return i;
         }
         return -1;
@@ -80,12 +86,14 @@ class Solution {
         for (let i = 0; i < n; i++) {
             let tank = gas[i] - cost[i];
             if (tank < 0) continue;
+
             let j = (i + 1) % n;
             while (j !== i) {
                 tank += gas[j] - cost[j];
                 if (tank < 0) break;
                 j = (j + 1) % n;
             }
+
             if (j === i) return i;
         }
         return -1;
@@ -101,14 +109,17 @@ public class Solution {
         for (int i = 0; i < n; i++) {
             int tank = gas[i] - cost[i];
             if (tank < 0) continue;
+
             int j = (i + 1) % n;
             while (j != i) {
                 tank += gas[j] - cost[j];
                 if (tank < 0) break;
                 j = (j + 1) % n;
             }
+
             if (j == i) return i;
         }
+
         return -1;
     }
 }
@@ -117,11 +128,13 @@ public class Solution {
 ```go
 func canCompleteCircuit(gas []int, cost []int) int {
     n := len(gas)
+
     for i := 0; i < n; i++ {
         tank := gas[i] - cost[i]
         if tank < 0 {
             continue
         }
+
         j := (i + 1) % n
         for j != i {
             tank += gas[j]
@@ -131,10 +144,12 @@ func canCompleteCircuit(gas []int, cost []int) int {
             }
             j = (j + 1) % n
         }
+
         if j == i {
             return i
         }
     }
+
     return -1
 }
 ```
@@ -166,6 +181,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
+        let n = gas.count
+
+        for i in 0..<n {
+            var tank = gas[i] - cost[i]
+            if tank < 0 {
+                continue
+            }
+
+            var j = (i + 1) % n
+            while j != i {
+                tank += gas[j]
+                tank -= cost[j]
+                if tank < 0 {
+                    break
+                }
+                j += 1
+                j %= n
+            }
+
+            if j == i {
+                return i
+            }
+        }
+
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -327,6 +374,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
+        let n = gas.count
+        var start = n - 1
+        var end = 0
+        var tank = gas[start] - cost[start]
+
+        while start > end {
+            if tank < 0 {
+                start -= 1
+                tank += gas[start] - cost[start]
+            } else {
+                tank += gas[end] - cost[end]
+                end += 1
+            }
+        }
+
+        return tank >= 0 ? start : -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -510,6 +580,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
+        if gas.reduce(0, +) < cost.reduce(0, +) {
+            return -1
+        }
+
+        var total = 0
+        var res = 0
+        for i in 0..<gas.count {
+            total += (gas[i] - cost[i])
+
+            if total < 0 {
+                total = 0
+                res = i + 1
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/generate-parentheses.md b/articles/generate-parentheses.md
index 09060b8eb..635ef1af4 100644
--- a/articles/generate-parentheses.md
+++ b/articles/generate-parentheses.md
@@ -224,6 +224,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func generateParenthesis(_ n: Int) -> [String] {
+        var res = [String]()
+
+        func isValid(_ s: String) -> Bool {
+            var open = 0
+            for c in s {
+                open += (c == "(") ? 1 : -1
+                if open < 0 {
+                    return false
+                }
+            }
+            return open == 0
+        }
+
+        func dfs(_ s: String) {
+            if s.count == n * 2 {
+                if isValid(s) {
+                    res.append(s)
+                }
+                return
+            }
+            dfs(s + "(")
+            dfs(s + ")")
+        }
+
+        dfs("")
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -442,6 +475,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func generateParenthesis(_ n: Int) -> [String] {
+        var stack = [Character]()
+        var res = [String]()
+
+        func backtrack(_ openN: Int, _ closedN: Int) {
+            if openN == n && closedN == n {
+                res.append(String(stack))
+                return
+            }
+
+            if openN < n {
+                stack.append("(")
+                backtrack(openN + 1, closedN)
+                stack.removeLast()
+            }
+
+            if closedN < openN {
+                stack.append(")")
+                backtrack(openN, closedN + 1)
+                stack.removeLast()
+            }
+        }
+
+        backtrack(0, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -606,6 +670,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func generateParenthesis(_ n: Int) -> [String] {
+        var res = [[String]](repeating: [], count: n + 1)
+        res[0] = [""]
+
+        for k in 0...n {
+            for i in 0..<k {
+                for left in res[i] {
+                    for right in res[k - i - 1] {
+                        res[k].append("(" + left + ")" + right)
+                    }
+                }
+            }
+        }
+
+        return res[n]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/hand-of-straights.md b/articles/hand-of-straights.md
index 728447cc2..773278b86 100644
--- a/articles/hand-of-straights.md
+++ b/articles/hand-of-straights.md
@@ -7,6 +7,7 @@ class Solution:
     def isNStraightHand(self, hand, groupSize):
         if len(hand) % groupSize:
             return False
+
         count = Counter(hand)
         hand.sort()
         for num in hand:
@@ -22,10 +23,12 @@ class Solution:
 public class Solution {
     public boolean isNStraightHand(int[] hand, int groupSize) {
         if (hand.length % groupSize != 0) return false;
+
         Map<Integer, Integer> count = new HashMap<>();
         for (int num : hand) {
             count.put(num, count.getOrDefault(num, 0) + 1);
         }
+
         Arrays.sort(hand);
         for (int num : hand) {
             if (count.get(num) > 0) {
@@ -45,8 +48,10 @@ class Solution {
 public:
     bool isNStraightHand(vector<int>& hand, int groupSize) {
         if (hand.size() % groupSize != 0) return false;
+
         unordered_map<int, int> count;
         for (int num : hand) count[num]++;
+
         sort(hand.begin(), hand.end());
         for (int num : hand) {
             if (count[num] > 0) {
@@ -72,10 +77,12 @@ class Solution {
         if (hand.length % groupSize !== 0) {
             return false;
         }
+
         const count = {};
         for (const num of hand) {
             count[num] = (count[num] || 0) + 1;
         }
+
         hand.sort((a, b) => a - b);
         for (const num of hand) {
             if (count[num] > 0) {
@@ -94,10 +101,12 @@ class Solution {
 public class Solution {
     public bool IsNStraightHand(int[] hand, int groupSize) {
         if (hand.Length % groupSize != 0) return false;
+
         var count = new Dictionary<int, int>();
         foreach (var num in hand) {
             count[num] = count.GetValueOrDefault(num, 0) + 1;
         }
+
         Array.Sort(hand);
         foreach (var num in hand) {
             if (count[num] > 0) {
@@ -164,6 +173,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isNStraightHand(_ hand: [Int], _ groupSize: Int) -> Bool {
+        if hand.count % groupSize != 0 {
+            return false
+        }
+
+        var count = [Int: Int]()
+        for num in hand {
+            count[num, default: 0] += 1
+        }
+
+        let sortedHand = hand.sorted()
+        for num in sortedHand {
+            if let freq = count[num], freq > 0 {
+                for i in num..<(num + groupSize) {
+                    if let f = count[i], f > 0 {
+                        count[i] = f - 1
+                    } else {
+                        return false
+                    }
+                }
+            }
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -410,6 +449,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isNStraightHand(_ hand: [Int], _ groupSize: Int) -> Bool {
+        if hand.count % groupSize != 0 {
+            return false
+        }
+
+        var count = [Int: Int]()
+        for n in hand {
+            count[n, default: 0] += 1
+        }
+
+        var minH = Heap<Int>(Array(count.keys))
+
+        while !minH.isEmpty {
+            guard let first = minH.min else { return false }
+
+            for i in first..<(first + groupSize) {
+                guard let freq = count[i] else { return false }
+                count[i] = freq - 1
+                if count[i] == 0 {
+                    if i != minH.min {
+                        return false
+                    }
+                    minH.removeMin()
+                }
+            }
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -655,6 +728,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isNStraightHand(_ hand: [Int], _ groupSize: Int) -> Bool {
+        if hand.count % groupSize != 0 {
+            return false
+        }
+
+        var count = [Int: Int]()
+        for num in hand {
+            count[num, default: 0] += 1
+        }
+
+        var queue = Deque<Int>()
+        var lastNum = -1
+        var openGroups = 0
+
+        for (num, numCount) in count.sorted(by: { $0.key < $1.key }) {
+            if (openGroups > 0 && num > lastNum + 1) || openGroups > numCount {
+                return false
+            }
+
+            queue.append(numCount - openGroups)
+            lastNum = num
+            openGroups = numCount
+
+            if queue.count == groupSize {
+                openGroups -= queue.removeFirst()
+            }
+        }
+        return openGroups == 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -673,6 +780,7 @@ class Solution:
     def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
         if len(hand) % groupSize != 0:
             return False
+
         count = Counter(hand)
         for num in hand:
             start = num
@@ -692,6 +800,7 @@ class Solution:
 public class Solution {
     public boolean isNStraightHand(int[] hand, int groupSize) {
         if (hand.length % groupSize != 0) return false;
+
         Map<Integer, Integer> count = new HashMap<>();
         for (int num : hand) {
             count.put(num, count.getOrDefault(num, 0) + 1);
@@ -720,6 +829,7 @@ class Solution {
 public:
     bool isNStraightHand(vector<int>& hand, int groupSize) {
         if (hand.size() % groupSize != 0) return false;
+
         unordered_map<int, int> count;
         for (int num : hand) count[num]++;
         
@@ -750,6 +860,7 @@ class Solution {
      */
     isNStraightHand(hand, groupSize) {
         if (hand.length % groupSize !== 0) return false;
+
         const count = new Map();
         hand.forEach(num => count.set(num, (count.get(num) || 0) + 1));
         
@@ -775,6 +886,7 @@ class Solution {
 public class Solution {
     public bool IsNStraightHand(int[] hand, int groupSize) {
         if (hand.Length % groupSize != 0) return false;
+
         Dictionary<int, int> count = new Dictionary<int, int>();
         foreach (int num in hand) {
             if (!count.ContainsKey(num)) count[num] = 0;
@@ -867,6 +979,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isNStraightHand(_ hand: [Int], _ groupSize: Int) -> Bool {
+        if hand.count % groupSize != 0 {
+            return false
+        }
+
+        var count = [Int: Int]()
+        for num in hand {
+            count[num, default: 0] += 1
+        }
+
+        for num in hand {
+            var start = num
+            while (count[start - 1] ?? 0) > 0 {
+                start -= 1
+            }
+            while start <= num {
+                while (count[start] ?? 0) > 0 {
+                    for i in start..<(start + groupSize) {
+                        if (count[i] ?? 0) == 0 {
+                            return false
+                        }
+                        count[i]! -= 1
+                    }
+                }
+                start += 1
+            }
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/house-robber-ii.md b/articles/house-robber-ii.md
index 9157646c6..0469d73df 100644
--- a/articles/house-robber-ii.md
+++ b/articles/house-robber-ii.md
@@ -131,6 +131,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        if nums.count == 1 {
+            return nums[0]
+        }
+
+        func dfs(_ i: Int, _ flag: Bool) -> Int {
+            if i >= nums.count || (flag && i == nums.count - 1) {
+                return 0
+            }
+            return max(dfs(i + 1, flag), nums[i] + dfs(i + 2, flag || i == 0))
+        }
+
+        return max(dfs(0, true), dfs(1, false))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -336,6 +355,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        if nums.count == 1 {
+            return nums[0]
+        }
+
+        var memo = Array(repeating: Array(repeating: -1, count: 2), count: nums.count)
+
+        func dfs(_ i: Int, _ flag: Bool) -> Int {
+            if i >= nums.count || (flag && i == nums.count - 1) {
+                return 0
+            }
+            if memo[i][flag ? 1 : 0] != -1 {
+                return memo[i][flag ? 1 : 0]
+            }
+
+            memo[i][flag ? 1 : 0] = max(
+                dfs(i + 1, flag), nums[i] + dfs(i + 2, flag || i == 0)
+            )
+
+            return memo[i][flag ? 1 : 0]
+        }
+
+        return max(dfs(0, true), dfs(1, false))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -553,6 +601,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        if nums.count == 1 {
+            return nums[0]
+        }
+        return max(helper(Array(nums[1...])), helper(Array(nums[..<(nums.count - 1)])))
+    }
+    
+    func helper(_ nums: [Int]) -> Int {
+        if nums.isEmpty {
+            return 0
+        }
+        if nums.count == 1 {
+            return nums[0]
+        }
+        
+        var dp = [Int](repeating: 0, count: nums.count)
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1])
+        
+        for i in 2..<nums.count {
+            dp[i] = max(dp[i - 1], nums[i] + dp[i - 2])
+        }
+        
+        return dp.last!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -734,6 +812,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        if nums.isEmpty {
+            return 0
+        }
+        if nums.count == 1 {
+            return nums[0]
+        }
+        
+        let candidate1 = nums[0]
+        let candidate2 = helper(Array(nums[1..<nums.count]))
+        let candidate3 = helper(Array(nums[0..<(nums.count - 1)]))
+        
+        return max(max(candidate1, candidate2), candidate3)
+    }
+
+    func helper(_ nums: [Int]) -> Int {
+        var rob1 = 0
+        var rob2 = 0
+        
+        for num in nums {
+            let newRob = max(rob1 + num, rob2)
+            rob1 = rob2
+            rob2 = newRob
+        }
+        
+        return rob2
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/house-robber.md b/articles/house-robber.md
index 6122135cb..22be9ba02 100644
--- a/articles/house-robber.md
+++ b/articles/house-robber.md
@@ -118,6 +118,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        func dfs(_ i: Int) -> Int {
+            if i >= nums.count {
+                return 0
+            }
+            return max(dfs(i + 1), nums[i] + dfs(i + 2))
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -291,6 +306,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        var memo = Array(repeating: -1, count: nums.count)
+
+        func dfs(_ i: Int) -> Int {
+            if i >= nums.count {
+                return 0
+            }
+            if memo[i] != -1 {
+                return memo[i]
+            }
+            memo[i] = max(dfs(i + 1), nums[i] + dfs(i + 2))
+            return memo[i]
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -455,6 +491,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        if nums.isEmpty {
+            return 0
+        }
+        if nums.count == 1 {
+            return nums[0]
+        }
+
+        var dp = Array(repeating: 0, count: nums.count)
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1])
+
+        for i in 2..<nums.count {
+            dp[i] = max(dp[i - 1], nums[i] + dp[i - 2])
+        }
+
+        return dp[nums.count - 1]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -580,6 +639,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        var rob1 = 0, rob2 = 0
+
+        for num in nums {
+            let temp = max(num + rob1, rob2)
+            rob1 = rob2
+            rob2 = temp
+        }
+
+        return rob2
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/implement-prefix-tree.md b/articles/implement-prefix-tree.md
index 493258c7b..3e4a303f2 100644
--- a/articles/implement-prefix-tree.md
+++ b/articles/implement-prefix-tree.md
@@ -363,6 +363,62 @@ class PrefixTree {
 }
 ```
 
+```swift
+class TrieNode {
+    var children: [TrieNode?]
+    var endOfWord: Bool
+
+    init() {
+        self.children = Array(repeating: nil, count: 26)
+        self.endOfWord = false
+    }
+}
+
+class PrefixTree {
+    private let root: TrieNode
+
+    init() {
+        self.root = TrieNode()
+    }
+
+    func insert(_ word: String) {
+        var cur = root
+        for c in word {
+            let i = Int(c.asciiValue! - Character("a").asciiValue!)
+            if cur.children[i] == nil {
+                cur.children[i] = TrieNode()
+            }
+            cur = cur.children[i]!
+        }
+        cur.endOfWord = true
+    }
+
+    func search(_ word: String) -> Bool {
+        var cur = root
+        for c in word {
+            let i = Int(c.asciiValue! - Character("a").asciiValue!)
+            if cur.children[i] == nil {
+                return false
+            }
+            cur = cur.children[i]!
+        }
+        return cur.endOfWord
+    }
+
+    func startsWith(_ prefix: String) -> Bool {
+        var cur = root
+        for c in prefix {
+            let i = Int(c.asciiValue! - Character("a").asciiValue!)
+            if cur.children[i] == nil {
+                return false
+            }
+            cur = cur.children[i]!
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -708,6 +764,59 @@ class PrefixTree {
 }
 ```
 
+```swift
+class TrieNode {
+    var children: [Character: TrieNode]
+    var endOfWord: Bool
+
+    init() {
+        self.children = [:]
+        self.endOfWord = false
+    }
+}
+
+class PrefixTree {
+    private let root: TrieNode
+
+    init() {
+        self.root = TrieNode()
+    }
+
+    func insert(_ word: String) {
+        var cur = root
+        for c in word {
+            if cur.children[c] == nil {
+                cur.children[c] = TrieNode()
+            }
+            cur = cur.children[c]!
+        }
+        cur.endOfWord = true
+    }
+
+    func search(_ word: String) -> Bool {
+        var cur = root
+        for c in word {
+            if cur.children[c] == nil {
+                return false
+            }
+            cur = cur.children[c]!
+        }
+        return cur.endOfWord
+    }
+
+    func startsWith(_ prefix: String) -> Bool {
+        var cur = root
+        for c in prefix {
+            if cur.children[c] == nil {
+                return false
+            }
+            cur = cur.children[c]!
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/insert-new-interval.md b/articles/insert-new-interval.md
index 367a09391..13f29a037 100644
--- a/articles/insert-new-interval.md
+++ b/articles/insert-new-interval.md
@@ -216,6 +216,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func insert(_ intervals: [[Int]], _ newInterval: [Int]) -> [[Int]] {
+        var intervals = intervals
+        var newInterval = newInterval
+        var res: [[Int]] = []
+        var i = 0
+        let n = intervals.count
+
+        while i < n && intervals[i][1] < newInterval[0] {
+            res.append(intervals[i])
+            i += 1
+        }
+
+        while i < n && newInterval[1] >= intervals[i][0] {
+            newInterval[0] = min(newInterval[0], intervals[i][0])
+            newInterval[1] = max(newInterval[1], intervals[i][1])
+            i += 1
+        }
+        res.append(newInterval)
+
+        while i < n {
+            res.append(intervals[i])
+            i += 1
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -512,6 +543,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func insert(_ intervals: [[Int]], _ newInterval: [Int]) -> [[Int]] {
+        if intervals.isEmpty {
+            return [newInterval]
+        }
+
+        var intervals = intervals
+        let target = newInterval[0]
+        var left = 0, right = intervals.count - 1
+
+        while left <= right {
+            let mid = (left + right) / 2
+            if intervals[mid][0] < target {
+                left = mid + 1
+            } else {
+                right = mid - 1
+            }
+        }
+
+        intervals.insert(newInterval, at: left)
+
+        var res: [[Int]] = []
+        for interval in intervals {
+            if res.isEmpty || res.last![1] < interval[0] {
+                res.append(interval)
+            } else {
+                res[res.count - 1][1] = max(res.last![1], interval[1])
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -707,6 +773,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func insert(_ intervals: [[Int]], _ newInterval: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var newInterval = newInterval
+
+        for i in 0..<intervals.count {
+            if newInterval[1] < intervals[i][0] {
+                res.append(newInterval)
+                res.append(contentsOf: intervals[i...])
+                return res
+            } else if newInterval[0] > intervals[i][1] {
+                res.append(intervals[i])
+            } else {
+                newInterval[0] = min(newInterval[0], intervals[i][0])
+                newInterval[1] = max(newInterval[1], intervals[i][1])
+            }
+        }
+
+        res.append(newInterval)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/interleaving-string.md b/articles/interleaving-string.md
index c5e0566de..3d124cd01 100644
--- a/articles/interleaving-string.md
+++ b/articles/interleaving-string.md
@@ -199,6 +199,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isInterleave(_ s1: String, _ s2: String, _ s3: String) -> Bool {
+        let n1 = s1.count, n2 = s2.count, n3 = s3.count
+        if n1 + n2 != n3 { return false }
+        
+        let s1 = Array(s1), s2 = Array(s2), s3 = Array(s3)
+        
+        func dfs(_ i: Int, _ j: Int, _ k: Int) -> Bool {
+            if k == n3 {
+                return i == n1 && j == n2
+            }
+            
+            if i < n1 && s1[i] == s3[k] {
+                if dfs(i + 1, j, k + 1) {
+                    return true
+                }
+            }
+            
+            if j < n2 && s2[j] == s3[k] {
+                if dfs(i, j + 1, k + 1) {
+                    return true
+                }
+            }
+            
+            return false
+        }
+        
+        return dfs(0, 0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -462,6 +495,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isInterleave(_ s1: String, _ s2: String, _ s3: String) -> Bool {
+        let m = s1.count, n = s2.count, l = s3.count
+        if m + n != l { return false }
+        
+        let s1 = Array(s1), s2 = Array(s2), s3 = Array(s3)
+        var dp = Array(repeating: Array(repeating: nil as Bool?, count: n + 1), count: m + 1)
+
+        func dfs(_ i: Int, _ j: Int, _ k: Int) -> Bool {
+            if k == l {
+                return i == m && j == n
+            }
+            if let cached = dp[i][j] {
+                return cached
+            }
+
+            var res = false
+            if i < m && s1[i] == s3[k] {
+                res = dfs(i + 1, j, k + 1)
+            }
+            if !res && j < n && s2[j] == s3[k] {
+                res = dfs(i, j + 1, k + 1)
+            }
+
+            dp[i][j] = res
+            return res
+        }
+
+        return dfs(0, 0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -660,6 +727,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isInterleave(_ s1: String, _ s2: String, _ s3: String) -> Bool {
+        let m = s1.count, n = s2.count, l = s3.count
+        if m + n != l { return false }
+
+        let s1 = Array(s1), s2 = Array(s2), s3 = Array(s3)
+        var dp = Array(repeating: Array(repeating: false, count: n + 1), count: m + 1)
+        dp[m][n] = true
+
+        for i in stride(from: m, through: 0, by: -1) {
+            for j in stride(from: n, through: 0, by: -1) {
+                if i < m && s1[i] == s3[i + j] && dp[i + 1][j] {
+                    dp[i][j] = true
+                }
+                if j < n && s2[j] == s3[i + j] && dp[i][j + 1] {
+                    dp[i][j] = true
+                }
+            }
+        }
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -904,6 +996,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isInterleave(_ s1: String, _ s2: String, _ s3: String) -> Bool {
+        var s1 = Array(s1), s2 = Array(s2), s3 = Array(s3)
+        var m = s1.count, n = s2.count
+        if m + n != s3.count { return false }
+        if n < m {
+            swap(&s1, &s2)
+            swap(&m, &n)
+        }
+
+        var dp = Array(repeating: false, count: n + 1)
+        dp[n] = true
+
+        for i in stride(from: m, through: 0, by: -1) {
+            var nextDp = Array(repeating: false, count: n + 1)
+            nextDp[n] = true
+            for j in stride(from: n, through: 0, by: -1) {
+                if i < m && s1[i] == s3[i + j] && dp[j] {
+                    nextDp[j] = true
+                }
+                if j < n && s2[j] == s3[i + j] && nextDp[j + 1] {
+                    nextDp[j] = true
+                }
+            }
+            dp = nextDp
+        }
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1155,6 +1279,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isInterleave(_ s1: String, _ s2: String, _ s3: String) -> Bool {
+        var s1 = Array(s1), s2 = Array(s2), s3 = Array(s3)
+        var m = s1.count, n = s2.count
+        if m + n != s3.count { return false }
+        if n < m {
+            swap(&s1, &s2)
+            swap(&m, &n)
+        }
+
+        var dp = Array(repeating: false, count: n + 1)
+        dp[n] = true
+
+        for i in stride(from: m, through: 0, by: -1) {
+            var nextDp = true
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                var res = false
+                if i < m && s1[i] == s3[i + j] && dp[j] {
+                    res = true
+                }
+                if j < n && s2[j] == s3[i + j] && nextDp {
+                    res = true
+                }
+                dp[j] = res
+                nextDp = dp[j]
+            }
+        }
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/invert-a-binary-tree.md b/articles/invert-a-binary-tree.md
index 2c7622067..33ee15f84 100644
--- a/articles/invert-a-binary-tree.md
+++ b/articles/invert-a-binary-tree.md
@@ -227,6 +227,44 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func invertTree(_ root: TreeNode?) -> TreeNode? {
+        guard let root = root else { return nil }
+        var queue = Deque<TreeNode>()
+        queue.append(root)
+
+        while !queue.isEmpty {
+            let node = queue.removeFirst()
+            (node.left, node.right) = (node.right, node.left)
+            
+            if let left = node.left {
+                queue.append(left)
+            }
+            if let right = node.right {
+                queue.append(right)
+            }
+        }
+        return root
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -253,10 +291,10 @@ class Solution:
         if not root: return None
 
         root.left, root.right = root.right, root.left
-        
+
         self.invertTree(root.left)
         self.invertTree(root.right)
-        
+
         return root
 ```
 
@@ -277,16 +315,18 @@ class Solution:
  * }
  */
 
-class Solution {
+public class Solution {
     public TreeNode invertTree(TreeNode root) {
         if (root == null) return null;
-        
-        TreeNode node = new TreeNode(root.val);
 
-        node.right = invertTree(root.left);
-        node.left = invertTree(root.right);
-        
-        return node;
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+
+        invertTree(root.left);
+        invertTree(root.right);
+
+        return root;
     }
 }
 ```
@@ -307,14 +347,13 @@ class Solution {
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
-        if (root == nullptr) return nullptr;
+        if (!root) return nullptr;
 
-        TreeNode* node = new TreeNode(root->val);
-        
-        node->right = invertTree(root->left);
-        node->left = invertTree(root->right);
+        swap(root->left, root->right);
+        invertTree(root->left);
+        invertTree(root->right);
 
-        return node;
+        return root;
     }
 };
 ```
@@ -337,14 +376,13 @@ class Solution {
      * @return {TreeNode}
      */
     invertTree(root) {
-        if (root === null) return null;
-
-        const node = new TreeNode(root.val);
+        if (!root) return null;
 
-        node.right = this.invertTree(root.left);
-        node.left = this.invertTree(root.right);
+        [root.left, root.right] = [root.right, root.left];
+        this.invertTree(root.left);
+        this.invertTree(root.right);
 
-        return node;
+        return root;
     }
 }
 ```
@@ -368,12 +406,95 @@ public class Solution {
     public TreeNode InvertTree(TreeNode root) {
         if (root == null) return null;
 
-        TreeNode node = new TreeNode(root.val);
-        
-        node.right = InvertTree(root.left);
-        node.left = InvertTree(root.right);
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+
+        InvertTree(root.left);
+        InvertTree(root.right);
 
-        return node;
+        return root;
+    }
+}
+```
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func invertTree(root *TreeNode) *TreeNode {
+    if root == nil {
+        return nil
+    }
+
+    root.Left, root.Right = root.Right, root.Left
+    invertTree(root.Left)
+    invertTree(root.Right)
+
+    return root
+}
+```
+
+```kotlin
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+ 
+class Solution {
+    fun invertTree(root: TreeNode?): TreeNode? {
+        if (root == null) return null
+
+        val temp = root.left
+        root.left = root.right
+        root.right = temp
+
+        invertTree(root.left)
+        invertTree(root.right)
+
+        return root
+    }
+}
+```
+
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func invertTree(_ root: TreeNode?) -> TreeNode? {
+        guard let root = root else { return nil }
+
+        (root.left, root.right) = (root.right, root.left)
+
+        invertTree(root.left)
+        invertTree(root.right)
+
+        return root
     }
 }
 ```
@@ -383,7 +504,7 @@ public class Solution {
 ### Time & Space Complexity
 
 * Time complexity: $O(n)$
-* Space complexity: $O(n)$
+* Space complexity: $O(n)$ for recursion stack.
 
 ---
 
@@ -592,6 +713,43 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func invertTree(_ root: TreeNode?) -> TreeNode? {
+        guard let root = root else { return nil }
+        var stack: [TreeNode] = [root]
+
+        while !stack.isEmpty {
+            let node = stack.removeLast()
+            (node.left, node.right) = (node.right, node.left)
+            
+            if let left = node.left {
+                stack.append(left)
+            }
+            if let right = node.right {
+                stack.append(right)
+            }
+        }
+        return root
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/is-anagram.md b/articles/is-anagram.md
index ae3a44534..eb996634a 100644
--- a/articles/is-anagram.md
+++ b/articles/is-anagram.md
@@ -112,6 +112,14 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isAnagram(_ s: String, _ t: String) -> Bool {
+        return s.count == t.count && s.sorted() == t.sorted()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -123,7 +131,7 @@ class Solution {
 
 ---
 
-## 2. Hash Table
+## 2. Hash Map
 
 ::tabs-start
 
@@ -266,6 +274,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isAnagram(_ s: String, _ t: String) -> Bool {
+        if s.count != t.count {
+            return false
+        }
+
+        var countS = [Character: Int]()
+        var countT = [Character: Int]()
+
+        let sArray = Array(s)
+        let tArray = Array(t)
+
+        for i in 0..<s.count {
+            countS[sArray[i], default: 0] += 1
+            countT[tArray[i], default: 0] += 1
+        }
+
+        return countS == countT
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -277,7 +308,7 @@ class Solution {
 
 ---
 
-## 3. Hash Table (Optimal)
+## 3. Hash Table (Using Array)
 
 ::tabs-start
 
@@ -434,6 +465,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isAnagram(_ s: String, _ t: String) -> Bool {
+        if s.count != t.count {
+            return false
+        }
+
+        var count = [Int](repeating: 0, count: 26)
+        let sArray = Array(s)
+        let tArray = Array(t)
+
+        for i in 0..<s.count {
+            count[Int(sArray[i].asciiValue!) - 97] += 1
+            count[Int(tArray[i].asciiValue!) - 97] -= 1
+        }
+
+        for val in count {
+            if val != 0 {
+                return false
+            }
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -441,4 +498,4 @@ class Solution {
 * Time complexity: $O(n + m)$
 * Space complexity: $O(1)$ since we have at most $26$ different characters.
 
-> Where $n$ is the length of string $s$ and $m$ is the length of string $t$.
+> Where $n$ is the length of string $s$ and $m$ is the length of string $t$.
\ No newline at end of file
diff --git a/articles/is-palindrome.md b/articles/is-palindrome.md
index e7675ceb9..9aea0c833 100644
--- a/articles/is-palindrome.md
+++ b/articles/is-palindrome.md
@@ -123,6 +123,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isPalindrome(_ s: String) -> Bool {
+        var newStr = ""
+
+        for c in s {
+            if c.isLetter || c.isNumber {
+                newStr.append(c.lowercased())
+            }
+        }
+
+        return newStr == String(newStr.reversed())
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -327,6 +343,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isPalindrome(_ s: String) -> Bool {
+        let chars = Array(s)
+        var l = 0, r = chars.count - 1
+
+        while l < r {
+            while l < r && !isAlphaNum(chars[l]) {
+                l += 1
+            }
+            while r > l && !isAlphaNum(chars[r]) {
+                r -= 1
+            }
+            if chars[l].lowercased() != chars[r].lowercased() {
+                return false
+            }
+            l += 1
+            r -= 1
+        }
+        return true
+    }
+
+    private func isAlphaNum(_ c: Character) -> Bool {
+        return c.isLetter || c.isNumber
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/islands-and-treasure.md b/articles/islands-and-treasure.md
index ff99ef107..86e92192f 100644
--- a/articles/islands-and-treasure.md
+++ b/articles/islands-and-treasure.md
@@ -302,6 +302,43 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func islandsAndTreasure(_ grid: inout [[Int]]) {
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        let INF = 2147483647
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+        var visit = Array(repeating: Array(repeating: false, count: COLS), count: ROWS)
+        
+        func dfs(_ r: Int, _ c: Int) -> Int {
+            if r < 0 || c < 0 || r >= ROWS || c >= COLS || grid[r][c] == -1 || visit[r][c] {
+                return INF
+            }
+            if grid[r][c] == 0 {
+                return 0
+            }
+            
+            visit[r][c] = true
+            var res = INF
+            for (dx, dy) in directions {
+                res = min(res, 1 + dfs(r + dx, c + dy))
+            }
+            visit[r][c] = false
+            return res
+        }
+        
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == INF {
+                    grid[r][c] = dfs(r, c)
+                }
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -651,6 +688,52 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func islandsAndTreasure(_ grid: inout [[Int]]) {
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+        let INF = 2147483647
+        
+        func bfs(_ r: Int, _ c: Int) -> Int {
+            var q = Deque<(Int, Int)>()
+            q.append((r, c))
+            var visit = Array(repeating: Array(repeating: false, count: COLS), count: ROWS)
+            visit[r][c] = true
+            var steps = 0
+            while !q.isEmpty {
+                let levelCount = q.count
+                for _ in 0..<levelCount {
+                    let (row, col) = q.removeFirst()
+                    if grid[row][col] == 0 {
+                        return steps
+                    }
+                    for (dr, dc) in directions {
+                        let nr = row + dr, nc = col + dc
+                        if (nr >= 0 && nr < ROWS && nc >= 0 && nc < COLS &&
+                            !visit[nr][nc] && grid[nr][nc] != -1) {
+                            visit[nr][nc] = true
+                            q.append((nr, nc))
+                        }
+                    }
+                }
+                steps += 1
+            }
+            return INF
+        }
+        
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == INF {
+                    grid[r][c] = bfs(r, c)
+                }
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -938,6 +1021,55 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Hashable {
+    let r: Int
+    let c: Int
+}
+
+class Solution {
+    func islandsAndTreasure(_ grid: inout [[Int]]) {
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        var visit = Set<Item>()
+        var q = Deque<Item>()
+        
+        func addCell(_ r: Int, _ c: Int) {
+            if r < 0 || c < 0 || r >= ROWS || c >= COLS { return }
+            let item = Item(r: r, c: c)
+            if visit.contains(item) || grid[r][c] == -1 { return }
+            visit.insert(item)
+            q.append(item)
+        }
+        
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == 0 {
+                    let item = Item(r: r, c: c)
+                    q.append(item)
+                    visit.insert(item)
+                }
+            }
+        }
+        
+        var dist = 0
+        while !q.isEmpty {
+            let count = q.count
+            for _ in 0..<count {
+                let item = q.removeFirst()
+                let r = item.r, c = item.c
+                grid[r][c] = dist
+                addCell(r + 1, c)
+                addCell(r - 1, c)
+                addCell(r, c + 1)
+                addCell(r, c - 1)
+            }
+            dist += 1
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/jump-game-ii.md b/articles/jump-game-ii.md
index 44e309136..db4a1b445 100644
--- a/articles/jump-game-ii.md
+++ b/articles/jump-game-ii.md
@@ -55,12 +55,16 @@ private:
         if (i == nums.size() - 1) {
             return 0;
         }
-        if (nums[i] == 0) return 1000000;
+        if (nums[i] == 0) {
+            return 1000000;
+        }
+
         int res = 1000000;
         int end = min((int)nums.size() - 1, i + nums[i]);
         for (int j = i + 1; j <= end; ++j) {
             res = min(res, 1 + dfs(nums, j));
         }
+
         return res;
     }
 };
@@ -162,6 +166,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func jump(_ nums: [Int]) -> Int {
+        func dfs(_ i: Int) -> Int {
+            if i == nums.count - 1 {
+                return 0
+            }
+            if nums[i] == 0 {
+                return 1000000
+            }
+
+            let end = min(nums.count - 1, i + nums[i])
+            var res = 1000000
+            for j in i + 1..<(end + 1) {
+                res = min(res, 1 + dfs(j))
+            }
+
+            return res
+        }
+        
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -382,6 +411,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    var memo: [Int: Int] = [:]
+
+    func jump(_ nums: [Int]) -> Int {
+        return dfs(nums, 0)
+    }
+
+    private func dfs(_ nums: [Int], _ i: Int) -> Int {
+        if let cachedResult = memo[i] {
+            return cachedResult
+        }
+        if i == nums.count - 1 {
+            return 0
+        }
+        if nums[i] == 0 {
+            return 1000000
+        }
+
+        var res = 1000000
+        let end = min(nums.count, i + nums[i] + 1)
+        for j in i + 1..<end {
+            res = min(res, 1 + dfs(nums, j))
+        }
+
+        memo[i] = res
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -532,6 +592,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func jump(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var dp = Array(repeating: 1000000, count: n)
+        dp[n - 1] = 0
+
+        for i in stride(from: n - 2, through: 0, by: -1) {
+            let end = min(n, i + nums[i] + 1)
+            for j in i + 1..<end {
+                dp[i] = min(dp[i], 1 + dp[j])
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -690,6 +769,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func jump(_ nums: [Int]) -> Int {
+        var res = 0
+        var l = 0
+        var r = 0
+
+        while r < nums.count - 1 {
+            var farthest = 0
+            for i in l...r {
+                farthest = max(farthest, i + nums[i])
+            }
+            l = r + 1
+            r = farthest
+            res += 1
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/jump-game.md b/articles/jump-game.md
index 850539bca..c5048055e 100644
--- a/articles/jump-game.md
+++ b/articles/jump-game.md
@@ -157,6 +157,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canJump(_ nums: [Int]) -> Bool {
+
+        func dfs(_ i: Int) -> Bool {
+            if i == nums.count - 1 {
+                return true
+            }
+
+            let end = min(nums.count - 1, i + nums[i])
+            for j in i + 1..<(end + 1) {
+                if dfs(j) {
+                    return true
+                }
+            }
+            return false
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -397,6 +420,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canJump(_ nums: [Int]) -> Bool {
+        var memo: [Int: Bool] = [:]
+
+        func dfs(_ i: Int) -> Bool {
+            if let cachedResult = memo[i] {
+                return cachedResult
+            }
+            if i == nums.count - 1 {
+                return true
+            }
+            if nums[i] == 0 {
+                return false
+            }
+
+            let end = min(nums.count, i + nums[i] + 1)
+            for j in i + 1..<end {
+                if dfs(j) {
+                    memo[i] = true
+                    return true
+                }
+            }
+
+            memo[i] = false
+            return false
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -562,6 +618,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canJump(_ nums: [Int]) -> Bool {
+        let n = nums.count
+        var dp = [Bool](repeating: false, count: n)
+        dp[n - 1] = true
+
+        for i in (0..<n - 1).reversed() {
+            let end = min(n, i + nums[i] + 1)
+            for j in (i + 1..<end) {
+                if dp[j] {
+                    dp[i] = true
+                    break
+                }
+            }
+        }
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -683,6 +760,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canJump(_ nums: [Int]) -> Bool {
+        var goal = nums.count - 1
+
+        for i in stride(from: nums.count - 2, through: 0, by: -1) {
+            if i + nums[i] >= goal {
+                goal = i
+            }
+        }
+
+        return goal == 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/k-closest-points-to-origin.md b/articles/k-closest-points-to-origin.md
index 823a5a33f..7882e7c18 100644
--- a/articles/k-closest-points-to-origin.md
+++ b/articles/k-closest-points-to-origin.md
@@ -75,6 +75,16 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func kClosest(_ points: [[Int]], _ k: Int) -> [[Int]] {
+        return points.sorted { ($0[0] * $0[0] + $0[1] * $0[1]) < ($1[0] * $1[0] + $1[1] * $1[1]) }
+                      .prefix(k)
+                      .map { $0 }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -84,7 +94,7 @@ class Solution {
 
 ---
 
-## 2. Min Heap
+## 2. Min-Heap
 
 ::tabs-start
 
@@ -242,6 +252,39 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let dist: Int
+    let x: Int
+    let y: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.dist < rhs.dist
+    }
+}
+
+class Solution {
+    func kClosest(_ points: [[Int]], _ k: Int) -> [[Int]] {
+        var minHeap = Heap<Item>()
+
+        for point in points {
+            let x = point[0], y = point[1]
+            let dist = x * x + y * y
+            minHeap.insert(Item(dist: dist, x: x, y: y))
+        }
+
+        var res = [[Int]]()
+        for _ in 0..<k {
+            if let item = minHeap.popMin() {
+                res.append([item.x, item.y])
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -430,6 +473,42 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let dist: Int
+    let x: Int
+    let y: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.dist > rhs.dist
+    }
+}
+
+class Solution {
+    func kClosest(_ points: [[Int]], _ k: Int) -> [[Int]] {
+        var maxHeap = Heap<Item>()
+
+        for point in points {
+            let x = point[0], y = point[1]
+            let dist = x * x + y * y
+            maxHeap.insert(Item(dist: dist, x: x, y: y))
+            if maxHeap.count > k {
+                _ = maxHeap.popMin()
+            }
+        }
+
+        var res = [[Int]]()
+        while !maxHeap.isEmpty {
+            if let item = maxHeap.popMin() {
+                res.append([item.x, item.y])
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -721,6 +800,46 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func kClosest(_ points: [[Int]], _ k: Int) -> [[Int]] {
+        var points = points
+
+        func euclidean(_ point: [Int]) -> Int {
+            return point[0] * point[0] + point[1] * point[1]
+        }
+        
+        func partition(_ l: Int, _ r: Int) -> Int {
+            let pivotIdx = r
+            let pivotDist = euclidean(points[pivotIdx])
+            var i = l
+            for j in l..<r {
+                if euclidean(points[j]) <= pivotDist {
+                    points.swapAt(i, j)
+                    i += 1
+                }
+            }
+            points.swapAt(i, r)
+            return i
+        }
+        
+        var l = 0, r = points.count - 1
+        var pivot = points.count
+        
+        while pivot != k {
+            pivot = partition(l, r)
+            if pivot < k {
+                l = pivot + 1
+            } else {
+                r = pivot - 1
+            }
+        }
+        
+        return Array(points[..<k])
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/kth-largest-element-in-an-array.md b/articles/kth-largest-element-in-an-array.md
index ba0f51363..28fa1c69b 100644
--- a/articles/kth-largest-element-in-an-array.md
+++ b/articles/kth-largest-element-in-an-array.md
@@ -67,6 +67,15 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
+        let sortedNums = nums.sorted()
+        return sortedNums[sortedNums.count - k]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -184,6 +193,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
+        var minHeap = Heap<Int>()
+
+        for num in nums {
+            minHeap.insert(num)
+            if minHeap.count > k {
+                _ = minHeap.removeMin()
+            }
+        }
+
+        return minHeap.popMin()!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -417,6 +443,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
+        var nums = nums
+        let k = nums.count - k
+
+        func quickSelect(_ l: Int, _ r: Int) -> Int {
+            let pivot = nums[r]
+            var p = l
+
+            for i in l..<r {
+                if nums[i] <= pivot {
+                    nums.swapAt(i, p)
+                    p += 1
+                }
+            }
+            nums.swapAt(p, r)
+
+            if p > k {
+                return quickSelect(l, p - 1)
+            } else if p < k {
+                return quickSelect(p + 1, r)
+            } else {
+                return nums[p]
+            }
+        }
+
+        return quickSelect(0, nums.count - 1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -822,6 +880,70 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func partition(_ nums: inout [Int], _ left: Int, _ right: Int) -> Int {
+        let mid = (left + right) >> 1
+        nums.swapAt(mid, left + 1)
+
+        if nums[left] < nums[right] {
+            nums.swapAt(left, right)
+        }
+        if nums[left + 1] < nums[right] {
+            nums.swapAt(left + 1, right)
+        }
+        if nums[left] < nums[left + 1] {
+            nums.swapAt(left, left + 1)
+        }
+
+        let pivot = nums[left + 1]
+        var i = left + 1
+        var j = right
+
+        while true {
+            repeat { i += 1 } while nums[i] > pivot
+            repeat { j -= 1 } while nums[j] < pivot
+
+            if i > j {
+                break
+            }
+            nums.swapAt(i, j)
+        }
+
+        nums.swapAt(left + 1, j)
+        return j
+    }
+
+    func quickSelect(_ nums: inout [Int], _ k: Int) -> Int {
+        var left = 0
+        var right = nums.count - 1
+
+        while true {
+            if right <= left + 1 {
+                if right == left + 1 && nums[right] > nums[left] {
+                    nums.swapAt(left, right)
+                }
+                return nums[k]
+            }
+
+            let j = partition(&nums, left, right)
+
+            if j >= k {
+                right = j - 1
+            }
+            if j <= k {
+                left = j + 1
+            }
+        }
+    }
+
+    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
+        var nums = nums
+        return quickSelect(&nums, k - 1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/kth-largest-integer-in-a-stream.md b/articles/kth-largest-integer-in-a-stream.md
index 7913b93ca..42a4f617a 100644
--- a/articles/kth-largest-integer-in-a-stream.md
+++ b/articles/kth-largest-integer-in-a-stream.md
@@ -124,12 +124,32 @@ class KthLargest(k: Int, nums: IntArray) {
 }
 ```
 
+```swift
+class KthLargest {
+    private var k: Int
+    private var arr: [Int]
+
+    init(_ k: Int, _ nums: [Int]) {
+        self.k = k
+        self.arr = nums
+    }
+
+    func add(_ val: Int) -> Int {
+        arr.append(val)
+        arr.sort()
+        return arr[arr.count - k]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(m * n\log n)$
-* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
+* Space complexity:
+    * $O(m)$ extra space.
+    * $O(1)$ or $O(n)$ space depending on the sorting algorithm.
 
 > Where $m$ is the number of calls made to $add()$ and $n$ is the current size of the array.
 
@@ -324,6 +344,32 @@ class KthLargest(k: Int, nums: IntArray) {
 }
 ```
 
+```swift
+class KthLargest {
+    private var minHeap: Heap<Int>
+    private let k: Int
+
+    init(_ k: Int, _ nums: [Int]) {
+        self.k = k
+        self.minHeap = Heap<Int>()
+        for num in nums {
+            minHeap.insert(num)
+            if minHeap.count > k {
+                minHeap.popMin()
+            }
+        }
+    }
+
+    func add(_ val: Int) -> Int {
+        minHeap.insert(val)
+        if minHeap.count > k {
+            minHeap.popMin()
+        }
+        return minHeap.min!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/kth-smallest-integer-in-bst.md b/articles/kth-smallest-integer-in-bst.md
index 1014ba6d4..ec5dfe795 100644
--- a/articles/kth-smallest-integer-in-bst.md
+++ b/articles/kth-smallest-integer-in-bst.md
@@ -225,6 +225,40 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        var arr = [Int]()
+
+        func dfs(_ node: TreeNode?) {
+            guard let node = node else { return }
+            arr.append(node.val)
+            dfs(node.left)
+            dfs(node.right)
+        }
+
+        dfs(root)
+        arr.sort()
+        return arr[k - 1]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -456,6 +490,39 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        var arr = [Int]()
+
+        func dfs(_ node: TreeNode?) {
+            guard let node = node else { return }
+            dfs(node.left)
+            arr.append(node.val)
+            dfs(node.right)
+        }
+
+        dfs(root)
+        return arr[k - 1]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -721,6 +788,45 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        var cnt = k
+        var res = root!.val
+
+        func dfs(_ node: TreeNode?) {
+            guard let node = node else { return }
+
+            dfs(node.left)
+            cnt -= 1
+            if cnt == 0 {
+                res = node.val
+                return
+            }
+            dfs(node.right)
+        }
+
+        dfs(root)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -983,6 +1089,45 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        var stack = [TreeNode]()
+        var curr = root
+        var k = k
+
+        while !stack.isEmpty || curr != nil {
+            while curr != nil {
+                stack.append(curr!)
+                curr = curr?.left
+            }
+            curr = stack.removeLast()
+            k -= 1
+            if k == 0 {
+                return curr!.val
+            }
+            curr = curr?.right
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1298,6 +1443,58 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        var curr = root
+        var k = k
+
+        while curr != nil {
+            if curr?.left == nil {
+                k -= 1
+                if k == 0 {
+                    return curr!.val
+                }
+                curr = curr?.right
+            } else {
+                var pred = curr?.left
+                while pred?.right != nil && pred?.right !== curr {
+                    pred = pred?.right
+                }
+                
+                if pred?.right == nil {
+                    pred?.right = curr
+                    curr = curr?.left
+                } else {
+                    pred?.right = nil
+                    k -= 1
+                    if k == 0 {
+                        return curr!.val
+                    }
+                    curr = curr?.right
+                }
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/largest-rectangle-in-histogram.md b/articles/largest-rectangle-in-histogram.md
index 54d44de5b..75df88ffe 100644
--- a/articles/largest-rectangle-in-histogram.md
+++ b/articles/largest-rectangle-in-histogram.md
@@ -203,6 +203,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func largestRectangleArea(_ heights: [Int]) -> Int {
+        let n = heights.count
+        var maxArea = 0
+
+        for i in 0..<n {
+            let height = heights[i]
+
+            var rightMost = i + 1
+            while rightMost < n && heights[rightMost] >= height {
+                rightMost += 1
+            }
+
+            var leftMost = i
+            while leftMost >= 0 && heights[leftMost] >= height {
+                leftMost -= 1
+            }
+
+            rightMost -= 1
+            leftMost += 1
+            maxArea = max(maxArea, height * (rightMost - leftMost + 1))
+        }
+
+        return maxArea
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -767,6 +796,86 @@ class Solution {
 }
 ```
 
+```swift
+class MinIdxSegmentTree {
+    private var n: Int
+    private var INF = Int(1e9)
+    private var A: [Int]
+    private var tree: [Int]
+
+    init(_ N: Int, _ A: [Int]) {
+        self.n = N
+        self.A = A
+        while (self.n & (self.n - 1)) != 0 {
+            self.A.append(self.INF)
+            self.n += 1
+        }
+        self.tree = [Int](repeating: 0, count: 2 * self.n)
+        build()
+    }
+
+    private func build() {
+        for i in 0..<n {
+            tree[n + i] = i
+        }
+        for j in stride(from: n - 1, through: 1, by: -1) {
+            let a = tree[j << 1]
+            let b = tree[(j << 1) + 1]
+            tree[j] = (A[a] <= A[b]) ? a : b
+        }
+    }
+
+    func update(_ i: Int, _ val: Int) {
+        A[i] = val
+        var j = (n + i) >> 1
+        while j >= 1 {
+            let a = tree[j << 1]
+            let b = tree[(j << 1) + 1]
+            tree[j] = (A[a] <= A[b]) ? a : b
+            j >>= 1
+        }
+    }
+
+    func query(_ ql: Int, _ qh: Int) -> Int {
+        return _query(1, 0, n - 1, ql, qh)
+    }
+
+    private func _query(_ node: Int, _ l: Int, _ h: Int, _ ql: Int, _ qh: Int) -> Int {
+        if ql > h || qh < l {
+            return INF
+        }
+        if l >= ql && h <= qh {
+            return tree[node]
+        }
+        let a = _query(node << 1, l, (l + h) >> 1, ql, qh)
+        let b = _query((node << 1) + 1, ((l + h) >> 1) + 1, h, ql, qh)
+        if a == INF { return b }
+        if b == INF { return a }
+        return (A[a] <= A[b]) ? a : b
+    }
+}
+
+class Solution {
+    func getMaxArea(_ heights: [Int], _ l: Int, _ r: Int, _ st: MinIdxSegmentTree) -> Int {
+        if l > r { return 0 }
+        if l == r { return heights[l] }
+
+        let minIdx = st.query(l, r)
+        return max(
+            max(getMaxArea(heights, l, minIdx - 1, st),
+                getMaxArea(heights, minIdx + 1, r, st)),
+            (r - l + 1) * heights[minIdx]
+        )
+    }
+
+    func largestRectangleArea(_ heights: [Int]) -> Int {
+        let n = heights.count
+        let st = MinIdxSegmentTree(n, heights)
+        return getMaxArea(heights, 0, n - 1, st)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1075,6 +1184,46 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func largestRectangleArea(_ heights: [Int]) -> Int {
+        let n = heights.count
+        var stack = [Int]()
+
+        var leftMost = [Int](repeating: -1, count: n)
+        for i in 0..<n {
+            while !stack.isEmpty && heights[stack.last!] >= heights[i] {
+                stack.removeLast()
+            }
+            if !stack.isEmpty {
+                leftMost[i] = stack.last!
+            }
+            stack.append(i)
+        }
+
+        stack.removeAll()
+        var rightMost = [Int](repeating: n, count: n)
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            while !stack.isEmpty && heights[stack.last!] >= heights[i] {
+                stack.removeLast()
+            }
+            if !stack.isEmpty {
+                rightMost[i] = stack.last!
+            }
+            stack.append(i)
+        }
+
+        var maxArea = 0
+        for i in 0..<n {
+            leftMost[i] += 1
+            rightMost[i] -= 1
+            maxArea = max(maxArea, heights[i] * (rightMost[i] - leftMost[i] + 1))
+        }
+        return maxArea
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1084,7 +1233,7 @@ class Solution {
 
 ---
 
-## 4. Stack (Optimal)
+## 4. Stack (One Pass)
 
 ::tabs-start
 
@@ -1283,6 +1432,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func largestRectangleArea(_ heights: [Int]) -> Int {
+        var maxArea = 0
+        var stack = [(Int, Int)]() // Pair: (index, height)
+
+        for (i, h) in heights.enumerated() {
+            var start = i
+            while !stack.isEmpty && stack.last!.1 > h {
+                let (index, height) = stack.removeLast()
+                maxArea = max(maxArea, height * (i - index))
+                start = index
+            }
+            stack.append((start, h))
+        }
+
+        for (i, h) in stack {
+            maxArea = max(maxArea, h * (heights.count - i))
+        }
+
+        return maxArea
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1292,7 +1466,7 @@ class Solution {
 
 ---
 
-## 5. Stack (One Pass)
+## 5. Stack (Optimal)
 
 ::tabs-start
 
@@ -1453,6 +1627,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func largestRectangleArea(_ heights: [Int]) -> Int {
+        let n = heights.count
+        var maxArea = 0
+        var stack = [Int]()
+
+        for i in 0...n {
+            while !stack.isEmpty && (i == n || heights[stack.last!] >= heights[i]) {
+                let height = heights[stack.removeLast()]
+                let width = stack.isEmpty ? i : i - stack.last! - 1
+                maxArea = max(maxArea, height * width)
+            }
+            stack.append(i)
+        }
+        return maxArea
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/last-stone-weight.md b/articles/last-stone-weight.md
index da1ec745e..69ab3403a 100644
--- a/articles/last-stone-weight.md
+++ b/articles/last-stone-weight.md
@@ -127,6 +127,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lastStoneWeight(_ stones: [Int]) -> Int {
+        var stones = stones
+        
+        while stones.count > 1 {
+            stones.sort()
+            let cur = stones.removeLast() - stones.removeLast()
+            if cur > 0 {
+                stones.append(cur)
+            }
+        }
+        
+        return stones.isEmpty ? 0 : stones[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -368,6 +386,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lastStoneWeight(_ stones: [Int]) -> Int {
+        var stones = stones.sorted()
+        var n = stones.count
+
+        while n > 1 {
+            let cur = stones.removeLast() - stones.removeLast()
+            n -= 2
+            if cur > 0 {
+                var l = 0, r = n
+                while l < r {
+                    let mid = (l + r) / 2
+                    if stones[mid] < cur {
+                        l = mid + 1
+                    } else {
+                        r = mid
+                    }
+                }
+                let pos = l
+                stones.append(0)
+                n += 1
+                for i in stride(from: n - 1, to: pos, by: -1) {
+                    stones[i] = stones[i - 1]
+                }
+                stones[pos] = cur
+            }
+        }
+
+        return n > 0 ? stones[0] : 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -543,6 +595,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lastStoneWeight(_ stones: [Int]) -> Int {
+        var heap = Heap(stones)
+        while heap.count > 1 {
+            let first = heap.popMax()!
+            let second = heap.popMax()!
+            if first > second {
+                heap.insert(first - second)
+            }
+        }
+        return heap.isEmpty ? 0 : heap.popMax()!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -843,6 +911,46 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lastStoneWeight(_ stones: [Int]) -> Int {
+        guard let maxStone = stones.max() else { return 0 }
+
+        var bucket = [Int](repeating: 0, count: maxStone + 1)
+        for stone in stones {
+            bucket[stone] += 1
+        }
+
+        var first = maxStone
+        var second = maxStone
+
+        while first > 0 {
+            if bucket[first] % 2 == 0 {
+                first -= 1
+                continue
+            }
+            
+            var j = min(first - 1, second)
+            while j > 0 && bucket[j] == 0 {
+                j -= 1
+            }
+            
+            if j == 0 {
+                return first
+            }
+            
+            second = j
+            bucket[first] -= 1
+            bucket[second] -= 1
+            bucket[first - second] += 1
+            first = max(first - second, second)
+        }
+        
+        return first
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/level-order-traversal-of-binary-tree.md b/articles/level-order-traversal-of-binary-tree.md
index 3bb08fe9a..28df7fc5f 100644
--- a/articles/level-order-traversal-of-binary-tree.md
+++ b/articles/level-order-traversal-of-binary-tree.md
@@ -19,11 +19,11 @@ class Solution:
                 return None
             if len(res) == depth:
                 res.append([])
-            
+
             res[depth].append(node.val)
             dfs(node.left, depth + 1)
             dfs(node.right, depth + 1)
-        
+
         dfs(root, 0)
         return res
 ```
@@ -251,6 +251,44 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func levelOrder(_ root: TreeNode?) -> [[Int]] {
+        var res = [[Int]]()
+
+        func dfs(_ node: TreeNode?, _ depth: Int) {
+            guard let node = node else { return }
+
+            if res.count == depth {
+                res.append([])
+            }
+
+            res[depth].append(node.val)
+            dfs(node.left, depth + 1)
+            dfs(node.right, depth + 1)
+        }
+
+        dfs(root, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -549,6 +587,48 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func levelOrder(_ root: TreeNode?) -> [[Int]] {
+        var res = [[Int]]()
+        var q = Deque<TreeNode?>()
+        q.append(root)
+
+        while !q.isEmpty {
+            let qLen = q.count
+            var level = [Int]()
+
+            for _ in 0..<qLen {
+                if let node = q.removeFirst() {
+                    level.append(node.val)
+                    q.append(node.left)
+                    q.append(node.right)
+                }
+            }
+            if !level.isEmpty {
+                res.append(level)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/linked-list-cycle-detection.md b/articles/linked-list-cycle-detection.md
index bcc21ee62..f8d574c77 100644
--- a/articles/linked-list-cycle-detection.md
+++ b/articles/linked-list-cycle-detection.md
@@ -186,6 +186,37 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func hasCycle(_ head: ListNode?) -> Bool {
+        var seen = Set<ObjectIdentifier>()
+        var cur = head
+
+        while cur != nil {
+            let nodeId = ObjectIdentifier(cur!)
+            if seen.contains(nodeId) {
+                return true
+            }
+            seen.insert(nodeId)
+            cur = cur?.next
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -387,6 +418,36 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.next = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func hasCycle(_ head: ListNode?) -> Bool {
+        var slow = head
+        var fast = head
+
+        while fast != nil && fast?.next != nil {
+            slow = slow?.next
+            fast = fast?.next?.next
+            if slow === fast {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-common-subsequence.md b/articles/longest-common-subsequence.md
index f75a48573..95c23cd86 100644
--- a/articles/longest-common-subsequence.md
+++ b/articles/longest-common-subsequence.md
@@ -136,6 +136,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
+        let arr1 = Array(text1)
+        let arr2 = Array(text2)
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == arr1.count || j == arr2.count {
+                return 0
+            }
+            if arr1[i] == arr2[j] {
+                return 1 + dfs(i + 1, j + 1)
+            }
+            return max(dfs(i + 1, j), dfs(i, j + 1))
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -363,6 +384,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
+        let arr1 = Array(text1)
+        let arr2 = Array(text2)
+        var memo = [String: Int]()
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == arr1.count || j == arr2.count {
+                return 0
+            }
+            let key = "\(i),\(j)"
+            if let val = memo[key] {
+                return val
+            }
+
+            if arr1[i] == arr2[j] {
+                memo[key] = 1 + dfs(i + 1, j + 1)
+            } else {
+                memo[key] = max(dfs(i + 1, j), dfs(i, j + 1))
+            }
+            return memo[key]!
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -534,6 +584,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
+        let m = text1.count
+        let n = text2.count
+        let arr1 = Array(text1)
+        let arr2 = Array(text2)
+
+        var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
+
+        for i in stride(from: m - 1, through: 0, by: -1) {
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                if arr1[i] == arr2[j] {
+                    dp[i][j] = 1 + dp[i + 1][j + 1]
+                } else {
+                    dp[i][j] = max(dp[i][j + 1], dp[i + 1][j])
+                }
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -749,6 +824,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
+        var t1 = Array(text1)
+        var t2 = Array(text2)
+
+        if t1.count < t2.count {
+            swap(&t1, &t2)
+        }
+
+        var prev = Array(repeating: 0, count: t2.count + 1)
+        var curr = Array(repeating: 0, count: t2.count + 1)
+
+        for i in stride(from: t1.count - 1, through: 0, by: -1) {
+            for j in stride(from: t2.count - 1, through: 0, by: -1) {
+                if t1[i] == t2[j] {
+                    curr[j] = 1 + prev[j + 1]
+                } else {
+                    curr[j] = max(curr[j + 1], prev[j])
+                }
+            }
+            swap(&prev, &curr)
+        }
+
+        return prev[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -966,6 +1070,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
+        var t1 = Array(text1)
+        var t2 = Array(text2)
+
+        if t1.count < t2.count {
+            swap(&t1, &t2)
+        }
+
+        var dp = Array(repeating: 0, count: t2.count + 1)
+
+        for i in stride(from: t1.count - 1, through: 0, by: -1) {
+            var prev = 0
+            for j in stride(from: t2.count - 1, through: 0, by: -1) {
+                let temp = dp[j]
+                if t1[i] == t2[j] {
+                    dp[j] = 1 + prev
+                } else {
+                    dp[j] = max(dp[j], dp[j + 1])
+                }
+                prev = temp
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-consecutive-sequence.md b/articles/longest-consecutive-sequence.md
index 9f7193486..22cd5db3f 100644
--- a/articles/longest-consecutive-sequence.md
+++ b/articles/longest-consecutive-sequence.md
@@ -143,6 +143,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        var res = 0
+        let store = Set(nums)
+
+        for num in nums {
+            var streak = 0
+            var curr = num
+
+            while store.contains(curr) {
+                streak += 1
+                curr += 1
+            }
+
+            res = max(res, streak)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -343,12 +366,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        if nums.isEmpty {
+            return 0
+        }
+        
+        var res = 0
+        var nums = nums.sorted()
+        
+        var curr = nums[0]
+        var streak = 0
+        var i = 0
+        
+        while i < nums.count {
+            if curr != nums[i] {
+                curr = nums[i]
+                streak = 0
+            }
+            while i < nums.count && nums[i] == curr {
+                i += 1
+            }
+            streak += 1
+            curr += 1
+            res = max(res, streak)
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n \log n)$
-* Space complexity: $O(1)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
 
 ---
 
@@ -506,6 +561,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        let numSet = Set(nums)
+        var longest = 0
+
+        for num in numSet {
+            if !numSet.contains(num - 1) {
+                var length = 1
+                while numSet.contains(num + length) {
+                    length += 1
+                }
+                longest = max(length, longest)
+            }
+        }
+
+        return longest
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -662,6 +738,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        var mp = [Int: Int]()
+        var res = 0
+
+        for num in nums {
+            if mp[num] == nil {
+                let left = mp[num - 1] ?? 0
+                let right = mp[num + 1] ?? 0
+                let length = left + right + 1
+
+                mp[num] = length
+                mp[num - left] = length
+                mp[num + right] = length
+
+                res = max(res, length)
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-increasing-path-in-matrix.md b/articles/longest-increasing-path-in-matrix.md
index 950ac6e73..e529b1ded 100644
--- a/articles/longest-increasing-path-in-matrix.md
+++ b/articles/longest-increasing-path-in-matrix.md
@@ -230,6 +230,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestIncreasingPath(_ matrix: [[Int]]) -> Int {
+        let rows = matrix.count, cols = matrix[0].count
+        let directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+        func dfs(_ r: Int, _ c: Int, _ prevVal: Int) -> Int {
+            if r < 0 || c < 0 || r >= rows || c >= cols || matrix[r][c] <= prevVal {
+                return 0
+            }
+            
+            var res = 1
+            for (dr, dc) in directions {
+                res = max(res, 1 + dfs(r + dr, c + dc, matrix[r][c]))
+            }
+            return res
+        }
+
+        var lip = 0
+        for r in 0..<rows {
+            for c in 0..<cols {
+                lip = max(lip, dfs(r, c, Int.min))
+            }
+        }
+        return lip
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -518,6 +547,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestIncreasingPath(_ matrix: [[Int]]) -> Int {
+        let rows = matrix.count, cols = matrix[0].count
+        var dp = Array(repeating: Array(repeating: -1, count: cols), count: rows)
+
+        func dfs(_ r: Int, _ c: Int, _ prevVal: Int) -> Int {
+            if r < 0 || r >= rows || c < 0 || c >= cols || matrix[r][c] <= prevVal {
+                return 0
+            }
+            if dp[r][c] != -1 {
+                return dp[r][c]
+            }
+
+            var res = 1
+            res = max(res, 1 + dfs(r + 1, c, matrix[r][c]))
+            res = max(res, 1 + dfs(r - 1, c, matrix[r][c]))
+            res = max(res, 1 + dfs(r, c + 1, matrix[r][c]))
+            res = max(res, 1 + dfs(r, c - 1, matrix[r][c]))
+
+            dp[r][c] = res
+            return res
+        }
+
+        var maxPath = 0
+        for r in 0..<rows {
+            for c in 0..<cols {
+                maxPath = max(maxPath, dfs(r, c, -1))
+            }
+        }
+        return maxPath
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -898,6 +962,56 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestIncreasingPath(_ matrix: [[Int]]) -> Int {
+        let rows = matrix.count, cols = matrix[0].count
+        let directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+        var indegree = Array(repeating: Array(repeating: 0, count: cols), count: rows)
+
+        for r in 0..<rows {
+            for c in 0..<cols {
+                for (dr, dc) in directions {
+                    let nr = r + dr, nc = c + dc
+                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
+                        matrix[nr][nc] < matrix[r][c]) {
+                        indegree[r][c] += 1
+                    }
+                }
+            }
+        }
+
+        var q = Deque<(Int, Int)>()
+        for r in 0..<rows {
+            for c in 0..<cols {
+                if indegree[r][c] == 0 {
+                    q.append((r, c))
+                }
+            }
+        }
+
+        var LIS = 0
+        while !q.isEmpty {
+            for _ in 0..<q.count {
+                let (r, c) = q.popFirst()!
+                for (dr, dc) in directions {
+                    let nr = r + dr, nc = c + dc
+                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
+                        matrix[nr][nc] > matrix[r][c]) {
+                        indegree[nr][nc] -= 1
+                        if indegree[nr][nc] == 0 {
+                            q.append((nr, nc))
+                        }
+                    }
+                }
+            }
+            LIS += 1
+        }
+        return LIS
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-increasing-subsequence.md b/articles/longest-increasing-subsequence.md
index 1b24412eb..79391921a 100644
--- a/articles/longest-increasing-subsequence.md
+++ b/articles/longest-increasing-subsequence.md
@@ -170,6 +170,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == nums.count {
+                return 0
+            }
+
+            var LIS = dfs(i + 1, j) // not include
+
+            if j == -1 || nums[j] < nums[i] {
+                LIS = max(LIS, 1 + dfs(i + 1, i)) // include
+            }
+
+            return LIS
+        }
+
+        return dfs(0, -1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -179,7 +201,7 @@ class Solution {
 
 ---
 
-## 2. Dynamic Programming (Top-Down)
+## 2. Dynamic Programming (Top-Down) - I
 
 ::tabs-start
 
@@ -410,6 +432,508 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var memo = Array(repeating: Array(repeating: -1, count: n + 1), count: n)
+
+        func dfs(_ i: Int, _ j: Int) -> Int {
+            if i == n {
+                return 0
+            }
+            if memo[i][j + 1] != -1 {
+                return memo[i][j + 1]
+            }
+
+            var LIS = dfs(i + 1, j) // not include
+
+            if j == -1 || nums[j] < nums[i] {
+                LIS = max(LIS, 1 + dfs(i + 1, i)) // include
+            }
+
+            memo[i][j + 1] = LIS
+            return LIS
+        }
+
+        return dfs(0, -1)
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(n ^ 2)$
+
+---
+
+## 3. Dynamic Programming (Top-Down) - II
+
+::tabs-start
+
+```python
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        memo = [-1] * n
+
+        def dfs(i):
+            if memo[i] != -1:
+                return memo[i]
+
+            LIS = 1
+            for j in range(i + 1, n):
+                if nums[i] < nums[j]:
+                    LIS = max(LIS, 1 + dfs(j))
+
+            memo[i] = LIS
+            return LIS
+
+        return max(dfs(i) for i in range(n))
+```
+
+```java
+public class Solution {
+    private int[] memo;
+
+    public int lengthOfLIS(int[] nums) {
+        int n = nums.length;
+        memo = new int[n];
+        Arrays.fill(memo, -1);
+
+        int maxLIS = 1;
+        for (int i = 0; i < n; i++) {
+            maxLIS = Math.max(maxLIS, dfs(nums, i));
+        }
+        return maxLIS;
+    }
+
+    private int dfs(int[] nums, int i) {
+        if (memo[i] != -1) {
+            return memo[i];
+        }
+
+        int LIS = 1;
+        for (int j = i + 1; j < nums.length; j++) {
+            if (nums[i] < nums[j]) {
+                LIS = Math.max(LIS, 1 + dfs(nums, j));
+            }
+        }
+
+        memo[i] = LIS;
+        return LIS;
+    }
+}
+```
+
+```cpp
+class Solution {
+private:
+    vector<int> memo;
+    
+    int dfs(vector<int>& nums, int i) {
+        if (memo[i] != -1) {
+            return memo[i];
+        }
+
+        int LIS = 1;
+        for (int j = i + 1; j < nums.size(); j++) {
+            if (nums[i] < nums[j]) {
+                LIS = max(LIS, 1 + dfs(nums, j));
+            }
+        }
+
+        return memo[i] = LIS;
+    }
+
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        int n = nums.size();
+        memo.assign(n, -1);
+
+        int maxLIS = 1;
+        for (int i = 0; i < n; i++) {
+            maxLIS = max(maxLIS, dfs(nums, i));
+        }
+        return maxLIS;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    lengthOfLIS(nums) {
+        const n = nums.length;
+        const memo = new Array(n).fill(-1);
+
+        const dfs = (i) => {
+            if (memo[i] !== -1) {
+                return memo[i];
+            }
+
+            let LIS = 1;
+            for (let j = i + 1; j < n; j++) {
+                if (nums[i] < nums[j]) {
+                    LIS = Math.max(LIS, 1 + dfs(j));
+                }
+            }
+
+            memo[i] = LIS;
+            return LIS;
+        };
+
+        return Math.max(...nums.map((_, i) => dfs(i)));
+    }
+}
+```
+
+```csharp
+public class Solution {
+    private int[] memo;
+
+    public int LengthOfLIS(int[] nums) {
+        int n = nums.Length;
+        memo = new int[n];
+        Array.Fill(memo, -1);
+
+        int maxLIS = 1;
+        for (int i = 0; i < n; i++) {
+            maxLIS = Math.Max(maxLIS, Dfs(nums, i));
+        }
+        return maxLIS;
+    }
+
+    private int Dfs(int[] nums, int i) {
+        if (memo[i] != -1) {
+            return memo[i];
+        }
+
+        int LIS = 1;
+        for (int j = i + 1; j < nums.Length; j++) {
+            if (nums[i] < nums[j]) {
+                LIS = Math.Max(LIS, 1 + Dfs(nums, j));
+            }
+        }
+
+        memo[i] = LIS;
+        return LIS;
+    }
+}
+```
+
+```go
+func lengthOfLIS(nums []int) int {
+    n := len(nums)
+    memo := make([]int, n)
+    for i := range memo {
+        memo[i] = -1
+    }
+
+    var dfs func(int) int
+    dfs = func(i int) int {
+        if memo[i] != -1 {
+            return memo[i]
+        }
+
+        LIS := 1
+        for j := i + 1; j < n; j++ {
+            if nums[i] < nums[j] {
+                LIS = max(LIS, 1+dfs(j))
+            }
+        }
+
+        memo[i] = LIS
+        return LIS
+    }
+
+    maxLIS := 1
+    for i := 0; i < n; i++ {
+        maxLIS = max(maxLIS, dfs(i))
+    }
+
+    return maxLIS
+}
+
+func max(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+```kotlin
+class Solution {
+    private lateinit var memo: IntArray
+
+    fun lengthOfLIS(nums: IntArray): Int {
+        val n = nums.size
+        memo = IntArray(n) { -1 }
+
+        var maxLIS = 1
+        for (i in nums.indices) {
+            maxLIS = maxOf(maxLIS, dfs(nums, i))
+        }
+        return maxLIS
+    }
+
+    private fun dfs(nums: IntArray, i: Int): Int {
+        if (memo[i] != -1) {
+            return memo[i]
+        }
+
+        var LIS = 1
+        for (j in i + 1 until nums.size) {
+            if (nums[i] < nums[j]) {
+                LIS = maxOf(LIS, 1 + dfs(nums, j))
+            }
+        }
+
+        memo[i] = LIS
+        return LIS
+    }
+}
+```
+
+```swift
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var memo = Array(repeating: -1, count: n)
+
+        func dfs(_ i: Int) -> Int {
+            if memo[i] != -1 {
+                return memo[i]
+            }
+
+            var LIS = 1
+            for j in (i + 1)..<n {
+                if nums[i] < nums[j] {
+                    LIS = max(LIS, 1 + dfs(j))
+                }
+            }
+
+            memo[i] = LIS
+            return LIS
+        }
+
+        return (0..<n).map { dfs($0) }.max()!
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Dynamic Programming (Bottom-Up) - I
+
+::tabs-start
+
+```python
+class Solution:
+    def lengthOfLIS(self, nums):
+        n = len(nums)
+        dp = [[0] * (n + 1) for _ in range(n + 1)]  
+
+        for i in range(n - 1, -1, -1):
+            for j in range(i - 1, -2, -1):
+                LIS = dp[i + 1][j + 1]  # Not including nums[i]
+
+                if j == -1 or nums[j] < nums[i]:
+                    LIS = max(LIS, 1 + dp[i + 1][i + 1])  # Including nums[i]
+
+                dp[i][j + 1] = LIS
+
+        return dp[0][0]
+```
+
+```java
+public class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int n = nums.length;
+        int[][] dp = new int[n + 1][n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i - 1; j >= -1; j--) {
+                int LIS = dp[i + 1][j + 1]; // Not including nums[i]
+
+                if (j == -1 || nums[j] < nums[i]) {
+                    LIS = Math.max(LIS, 1 + dp[i + 1][i + 1]); // Including nums[i]
+                }
+
+                dp[i][j + 1] = LIS;
+            }
+        }
+
+        return dp[0][0];
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        int n = nums.size();
+        vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
+
+        for (int i = n - 1; i >= 0; --i) {
+            for (int j = i - 1; j >= -1; --j) {
+                int LIS = dp[i + 1][j + 1]; // Not including nums[i]
+
+                if (j == -1 || nums[j] < nums[i]) {
+                    LIS = max(LIS, 1 + dp[i + 1][i + 1]); // Including nums[i]
+                }
+
+                dp[i][j + 1] = LIS;
+            }
+        }
+
+        return dp[0][0];
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    lengthOfLIS(nums) {
+        const n = nums.length;
+        const dp = Array.from({ length: n + 1 }, () => new Array(n + 1).fill(0));
+
+        for (let i = n - 1; i >= 0; i--) {
+            for (let j = i - 1; j >= -1; j--) {
+                let LIS = dp[i + 1][j + 1]; // Not including nums[i]
+
+                if (j === -1 || nums[j] < nums[i]) {
+                    LIS = Math.max(LIS, 1 + dp[i + 1][i + 1]); // Including nums[i]
+                }
+
+                dp[i][j + 1] = LIS;
+            }
+        }
+
+        return dp[0][0];
+    }
+}
+```
+
+```csharp
+public class Solution {
+    public int LengthOfLIS(int[] nums) {
+        int n = nums.Length;
+        int[,] dp = new int[n + 1, n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i - 1; j >= -1; j--) {
+                int LIS = dp[i + 1, j + 1]; // Not including nums[i]
+
+                if (j == -1 || nums[j] < nums[i]) {
+                    LIS = Math.Max(LIS, 1 + dp[i + 1, i + 1]); // Including nums[i]
+                }
+
+                dp[i, j + 1] = LIS;
+            }
+        }
+
+        return dp[0, 0];
+    }
+}
+```
+
+```go
+func lengthOfLIS(nums []int) int {
+    n := len(nums)
+    dp := make([][]int, n+1)
+    for i := range dp {
+        dp[i] = make([]int, n+1)
+    }
+
+    for i := n - 1; i >= 0; i-- {
+        for j := i - 1; j >= -1; j-- {
+            LIS := dp[i+1][j+1] // Not including nums[i]
+
+            if j == -1 || nums[j] < nums[i] {
+                LIS = max(LIS, 1+dp[i+1][i+1]) // Including nums[i]
+            }
+
+            dp[i][j+1] = LIS
+        }
+    }
+
+    return dp[0][0]
+}
+
+func max(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+```kotlin
+class Solution {
+    fun lengthOfLIS(nums: IntArray): Int {
+        val n = nums.size
+        val dp = Array(n + 1) { IntArray(n + 1) }
+
+        for (i in n - 1 downTo 0) {
+            for (j in i - 1 downTo -1) {
+                var LIS = dp[i + 1][j + 1] // Not including nums[i]
+
+                if (j == -1 || nums[j] < nums[i]) {
+                    LIS = maxOf(LIS, 1 + dp[i + 1][i + 1]) // Including nums[i]
+                }
+
+                dp[i][j + 1] = LIS
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
+```swift
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: n + 1)
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            for j in stride(from: i - 1, through: -1, by: -1) {
+                var LIS = dp[i + 1][j + 1] // Not including nums[i]
+
+                if j == -1 || nums[j] < nums[i] {
+                    LIS = max(LIS, 1 + dp[i + 1][i + 1]) // Including nums[i]
+                }
+
+                dp[i][j + 1] = LIS
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -419,7 +943,7 @@ class Solution {
 
 ---
 
-## 3. Dynamic Programming (Bottom-Up)
+## 5. Dynamic Programming (Bottom-Up) - II
 
 ::tabs-start
 
@@ -556,6 +1080,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        var LIS = Array(repeating: 1, count: nums.count)
+
+        for i in stride(from: nums.count - 1, through: 0, by: -1) {
+            for j in (i + 1)..<nums.count {
+                if nums[i] < nums[j] {
+                    LIS[i] = max(LIS[i], 1 + LIS[j])
+                }
+            }
+        }
+        return LIS.max()!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -565,7 +1106,7 @@ class Solution {
 
 ---
 
-## 4. Segment Tree
+## 6. Segment Tree
 
 ::tabs-start
 
@@ -624,7 +1165,7 @@ class Solution:
 ```
 
 ```java
-public class SegmentTree {
+class SegmentTree {
     int n;
     int[] tree;
 
@@ -1050,6 +1591,73 @@ class Solution {
 }
 ```
 
+```swift
+class SegmentTree {
+    private var n: Int
+    private var tree: [Int]
+
+    init(_ N: Int) {
+        self.n = N
+        while (self.n & (self.n - 1)) != 0 {
+            self.n += 1
+        }
+        self.tree = Array(repeating: 0, count: 2 * self.n)
+    }
+
+    func update(_ i: Int, _ val: Int) {
+        tree[n + i] = val
+        var j = (n + i) >> 1
+        while j >= 1 {
+            tree[j] = max(tree[j << 1], tree[j << 1 | 1])
+            j >>= 1
+        }
+    }
+
+    func query(_ l: Int, _ r: Int) -> Int {
+        if l > r {
+            return 0
+        }
+        var res = Int.min
+        var l = l + n
+        var r = r + n + 1
+        while l < r {
+            if l & 1 == 1 {
+                res = max(res, tree[l])
+                l += 1
+            }
+            if r & 1 == 1 {
+                r -= 1
+                res = max(res, tree[r])
+            }
+            l >>= 1
+            r >>= 1
+        }
+        return res
+    }
+}
+
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        func compress(_ arr: [Int]) -> [Int] {
+            let sortedArr = Array(Set(arr)).sorted()
+            return arr.map { sortedArr.firstIndex(of: $0)! }
+        }
+
+        let nums = compress(nums)
+        let n = nums.count
+        let segTree = SegmentTree(n)
+
+        var LIS = 0
+        for num in nums {
+            let curLIS = segTree.query(0, num - 1) + 1
+            segTree.update(num, curLIS)
+            LIS = max(LIS, curLIS)
+        }
+        return LIS
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1059,7 +1667,7 @@ class Solution {
 
 ---
 
-## 5. Binary Search
+## 7. Dynamic Programming + Binary Search
 
 ::tabs-start
 
@@ -1237,6 +1845,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        var dp = [nums[0]]
+        var LIS = 1
+
+        for i in 1..<nums.count {
+            if let last = dp.last, last < nums[i] {
+                dp.append(nums[i])
+                LIS += 1
+            } else {
+                let idx = binarySearch(dp, nums[i])
+                dp[idx] = nums[i]
+            }
+        }
+        return LIS
+    }
+
+    private func binarySearch(_ dp: [Int], _ target: Int) -> Int {
+        var left = 0, right = dp.count - 1
+        while left < right {
+            let mid = (left + right) / 2
+            if dp[mid] < target {
+                left = mid + 1
+            } else {
+                right = mid
+            }
+        }
+        return left
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-palindromic-substring.md b/articles/longest-palindromic-substring.md
index 715d7c512..1d0f82c17 100644
--- a/articles/longest-palindromic-substring.md
+++ b/articles/longest-palindromic-substring.md
@@ -180,12 +180,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestPalindrome(_ s: String) -> String {
+        let chars = Array(s)
+        var res = ""
+        var resLen = 0
+
+        for i in 0..<chars.count {
+            for j in i..<chars.count {
+                var l = i, r = j
+                while l < r && chars[l] == chars[r] {
+                    l += 1
+                    r -= 1
+                }
+                
+                if l >= r && resLen < (j - i + 1) {
+                    res = String(chars[i...j])
+                    resLen = j - i + 1
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n ^ 3)$
-* Space complexity: $O(1)$
+* Space complexity: $O(n)$
 
 ---
 
@@ -377,6 +403,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestPalindrome(_ s: String) -> String {
+        let chars = Array(s)
+        let n = chars.count
+        var resIdx = 0, resLen = 0
+        var dp = Array(repeating: Array(repeating: false, count: n), count: n)
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            for j in i..<n {
+                if chars[i] == chars[j] && (j - i <= 2 || dp[i + 1][j - 1]) {
+                    dp[i][j] = true
+                    if resLen < (j - i + 1) {
+                        resIdx = i
+                        resLen = j - i + 1
+                    }
+                }
+            }
+        }
+
+        return String(chars[resIdx..<resIdx + resLen])
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -642,12 +693,51 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestPalindrome(_ s: String) -> String {
+        let chars = Array(s)
+        var resIdx = 0
+        var resLen = 0
+
+        for i in 0..<chars.count {
+            // Odd length palindrome
+            var l = i, r = i
+            while l >= 0 && r < chars.count && chars[l] == chars[r] {
+                if (r - l + 1) > resLen {
+                    resIdx = l
+                    resLen = r - l + 1
+                }
+                l -= 1
+                r += 1
+            }
+
+            // Even length palindrome
+            l = i
+            r = i + 1
+            while l >= 0 && r < chars.count && chars[l] == chars[r] {
+                if (r - l + 1) > resLen {
+                    resIdx = l
+                    resLen = r - l + 1
+                }
+                l -= 1
+                r += 1
+            }
+        }
+
+        return String(chars[resIdx..<resIdx + resLen])
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n ^ 2)$
-* Space complexity: $O(1)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output string.
 
 ---
 
@@ -912,6 +1002,50 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func longestPalindrome(_ s: String) -> String {
+        func manacher(_ s: String) -> [Int] {
+            let t = "#" + s.map { String($0) }.joined(separator: "#") + "#"
+            let tArray = Array(t)
+            let n = tArray.count
+            var p = [Int](repeating: 0, count: n)
+            var l = 0, r = 0
+
+            for i in 0..<n {
+                if i < r {
+                    p[i] = min(r - i, p[l + (r - i)])
+                } else {
+                    p[i] = 0
+                }
+                while (i + p[i] + 1 < n && i - p[i] - 1 >= 0 &&
+                       tArray[i + p[i] + 1] == tArray[i - p[i] - 1]) {
+                    p[i] += 1
+                }
+                if i + p[i] > r {
+                    l = i - p[i]
+                    r = i + p[i]
+                }
+            }
+            return p
+        }
+
+        let p = manacher(s)
+        var resLen = 0, centerIndex = 0
+        for (i, v) in p.enumerated() {
+            if v > resLen {
+                resLen = v
+                centerIndex = i
+            }
+        }
+        let resIdx = (centerIndex - resLen) / 2
+        let start = s.index(s.startIndex, offsetBy: resIdx)
+        let end = s.index(start, offsetBy: resLen)
+        return String(s[start..<end])
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-repeating-substring-with-replacement.md b/articles/longest-repeating-substring-with-replacement.md
index ad806623e..481559d2d 100644
--- a/articles/longest-repeating-substring-with-replacement.md
+++ b/articles/longest-repeating-substring-with-replacement.md
@@ -151,6 +151,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func characterReplacement(_ s: String, _ k: Int) -> Int {
+        var res = 0
+        let chars = Array(s)
+
+        for i in 0..<chars.count {
+            var count = [Character: Int]()
+            var maxf = 0
+
+            for j in i..<chars.count {
+                count[chars[j], default: 0] += 1
+                maxf = max(maxf, count[chars[j]]!)
+
+                if (j - i + 1) - maxf <= k {
+                    res = max(res, j - i + 1)
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -376,6 +400,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func characterReplacement(_ s: String, _ k: Int) -> Int {
+        var res = 0
+        let charSet = Set(s)
+        let chars = Array(s)
+
+        for c in charSet {
+            var count = 0, l = 0
+
+            for r in 0..<chars.count {
+                if chars[r] == c {
+                    count += 1
+                }
+
+                while (r - l + 1) - count > k {
+                    if chars[l] == c {
+                        count -= 1
+                    }
+                    l += 1
+                }
+
+                res = max(res, r - l + 1)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -563,6 +617,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func characterReplacement(_ s: String, _ k: Int) -> Int {
+        var count = [Character: Int]()
+        var res = 0
+        var l = 0, maxf = 0
+        let chars = Array(s)
+
+        for r in 0..<chars.count {
+            count[chars[r], default: 0] += 1
+            maxf = max(maxf, count[chars[r]]!)
+
+            while (r - l + 1) - maxf > k {
+                count[chars[l], default: 0] -= 1
+                l += 1
+            }
+            res = max(res, r - l + 1)
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-substring-without-duplicates.md b/articles/longest-substring-without-duplicates.md
index a37747ed3..3d197dc21 100644
--- a/articles/longest-substring-without-duplicates.md
+++ b/articles/longest-substring-without-duplicates.md
@@ -137,6 +137,27 @@ class Solution {
 }
 ```
 
+```kotlin
+class Solution {
+    func lengthOfLongestSubstring(_ s: String) -> Int {
+        var res = 0
+        let chars = Array(s)
+
+        for i in 0..<chars.count {
+            var charSet = Set<Character>()
+            for j in i..<chars.count {
+                if charSet.contains(chars[j]) {
+                    break
+                }
+                charSet.insert(chars[j])
+            }
+            res = max(res, charSet.count)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -292,6 +313,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lengthOfLongestSubstring(_ s: String) -> Int {
+        var charSet = Set<Character>()
+        var l = 0, res = 0
+        let chars = Array(s)
+
+        for r in 0..<chars.count {
+            while charSet.contains(chars[r]) {
+                charSet.remove(chars[l])
+                l += 1
+            }
+            charSet.insert(chars[r])
+            res = max(res, r - l + 1)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -436,6 +477,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func lengthOfLongestSubstring(_ s: String) -> Int {
+        var mp = [Character: Int]()
+        var l = 0, res = 0
+        let chars = Array(s)
+
+        for r in 0..<chars.count {
+            if let index = mp[chars[r]] {
+                l = max(index + 1, l)
+            }
+            mp[chars[r]] = r
+            res = max(res, r - l + 1)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/lowest-common-ancestor-in-binary-search-tree.md b/articles/lowest-common-ancestor-in-binary-search-tree.md
index 70d66615b..798316614 100644
--- a/articles/lowest-common-ancestor-in-binary-search-tree.md
+++ b/articles/lowest-common-ancestor-in-binary-search-tree.md
@@ -211,6 +211,38 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.left = nil
+ *         self.right = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func lowestCommonAncestor(_ root: TreeNode?, _ p: TreeNode?, _ q: TreeNode?) -> TreeNode? {
+        guard let root = root, let p = p, let q = q else {
+            return nil
+        }
+
+        if max(p.val, q.val) < root.val {
+            return lowestCommonAncestor(root.left, p, q)
+        } else if min(p.val, q.val) > root.val {
+            return lowestCommonAncestor(root.right, p, q)
+        } else {
+            return root
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -436,6 +468,41 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.left = nil
+ *         self.right = nil
+ *     }
+ * }
+ */
+
+class Solution {
+    func lowestCommonAncestor(_ root: TreeNode?, _ p: TreeNode?, _ q: TreeNode?) -> TreeNode? {
+        var cur = root
+
+        while let node = cur {
+            if let p = p, let q = q {
+                if p.val > node.val && q.val > node.val {
+                    cur = node.right
+                } else if p.val < node.val && q.val < node.val {
+                    cur = node.left
+                } else {
+                    return node
+                }
+            }
+        }
+        return nil
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/lru-cache.md b/articles/lru-cache.md
index d93c79886..2bd939f9c 100644
--- a/articles/lru-cache.md
+++ b/articles/lru-cache.md
@@ -279,6 +279,46 @@ class LRUCache(capacity: Int) {
 }
 ```
 
+```swift
+class LRUCache {
+    private var cache: [(Int, Int)]
+    private let capacity: Int
+
+    init(_ capacity: Int) {
+        self.cache = []
+        self.capacity = capacity
+    }
+
+    func get(_ key: Int) -> Int {
+        for i in 0..<cache.count {
+            if cache[i].0 == key {
+                let tmp = cache.remove(at: i)
+                cache.append(tmp)
+                return tmp.1
+            }
+        }
+        return -1
+    }
+
+    func put(_ key: Int, _ value: Int) {
+        for i in 0..<cache.count {
+            if cache[i].0 == key {
+                var tmp = cache.remove(at: i)
+                tmp.1 = value
+                cache.append(tmp)
+                return
+            }
+        }
+
+        if cache.count == capacity {
+            cache.removeFirst()
+        }
+
+        cache.append((key, value))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -763,6 +803,76 @@ class LRUCache(capacity: Int) {
 }
 ```
 
+```swift
+class Node {
+    var key: Int
+    var val: Int
+    var prev: Node?
+    var next: Node?
+
+    init(_ key: Int, _ val: Int) {
+        self.key = key
+        self.val = val
+    }
+}
+
+class LRUCache {
+    private var cap: Int
+    private var cache: [Int: Node] = [:]
+    private var left: Node
+    private var right: Node
+
+    init(_ capacity: Int) {
+        self.cap = capacity
+        self.left = Node(0, 0)
+        self.right = Node(0, 0)
+        self.left.next = self.right
+        self.right.prev = self.left
+    }
+
+    private func remove(_ node: Node?) {
+        let prev = node?.prev
+        let next = node?.next
+        prev?.next = next
+        next?.prev = prev
+    }
+
+    private func insert(_ node: Node?) {
+        let prev = right.prev
+        let next = right
+        prev?.next = node
+        next.prev = node
+        node?.prev = prev
+        node?.next = next
+    }
+
+    func get(_ key: Int) -> Int {
+        if let node = cache[key] {
+            remove(node)
+            insert(node)
+            return node.val
+        }
+        return -1
+    }
+
+    func put(_ key: Int, _ value: Int) {
+        if let node = cache[key] {
+            remove(node)
+        }
+        let newNode = Node(key, value)
+        cache[key] = newNode
+        insert(newNode)
+
+        if cache.count > cap {
+            if let lru = left.next {
+                remove(lru)
+                cache.removeValue(forKey: lru.key)
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1002,6 +1112,45 @@ class LRUCache(capacity: Int) {
 }
 ```
 
+```swift
+class LRUCache {
+    private var capacity: Int
+    private var cache: [Int: Int] = [:]
+    private var keyOrder: [Int] = []
+
+    init(_ capacity: Int) {
+        self.capacity = capacity
+    }
+
+    func get(_ key: Int) -> Int {
+        if let value = cache[key] {
+            if let index = keyOrder.firstIndex(of: key) {
+                keyOrder.remove(at: index)
+            }
+            keyOrder.append(key)
+            return value
+        }
+        return -1
+    }
+
+    func put(_ key: Int, _ value: Int) {
+        if cache[key] != nil {
+            if let index = keyOrder.firstIndex(of: key) {
+                keyOrder.remove(at: index)
+            }
+        } else if cache.count >= capacity {
+            if let lruKey = keyOrder.first {
+                cache.removeValue(forKey: lruKey)
+                keyOrder.removeFirst()
+            }
+        }
+
+        cache[key] = value
+        keyOrder.append(key)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/max-area-of-island.md b/articles/max-area-of-island.md
index 22f9f8b53..cb69ca56d 100644
--- a/articles/max-area-of-island.md
+++ b/articles/max-area-of-island.md
@@ -232,6 +232,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        var visit = Set<[Int]>()
+        var grid = grid
+
+        func dfs(_ r: Int, _ c: Int) -> Int {
+            if (r < 0 || r == ROWS || c < 0 || c == COLS ||
+                grid[r][c] == 0 || visit.contains([r, c])) {
+                return 0
+            }
+            visit.insert([r, c])
+            return 1 + dfs(r + 1, c) + dfs(r - 1, c) + dfs(r, c + 1) + dfs(r, c - 1)
+        }
+
+        var area = 0
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                area = max(area, dfs(r, c))
+            }
+        }
+        return area
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -562,6 +590,50 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
+        let directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        var grid = grid
+        var area = 0
+
+        func bfs(_ r: Int, _ c: Int) -> Int {
+            var queue = Deque<(Int, Int)>()
+            grid[r][c] = 0
+            queue.append((r, c))
+            var res = 1
+
+            while !queue.isEmpty {
+                let (row, col) = queue.popFirst()!
+                for dir in directions {
+                    let nr = row + dir[0]
+                    let nc = col + dir[1]
+                    if nr < 0 || nc < 0 || nr >= ROWS || nc >= COLS || grid[nr][nc] == 0 {
+                        continue
+                    }
+                    queue.append((nr, nc))
+                    grid[nr][nc] = 0
+                    res += 1
+                }
+            }
+            return res
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == 1 {
+                    area = max(area, bfs(r, c))
+                }
+            }
+        }
+
+        return area
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -634,7 +706,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     private int[] Parent, Size;
 
     public DSU(int n) {
@@ -1081,6 +1153,80 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    private var parent: [Int]
+    private var size: [Int]
+
+    init(_ n: Int) {
+        parent = Array(0...n)
+        size = Array(repeating: 1, count: n + 1)
+    }
+
+    func find(_ node: Int) -> Int {
+        if parent[node] != node {
+            parent[node] = find(parent[node])
+        }
+        return parent[node]
+    }
+
+    func union(_ u: Int, _ v: Int) -> Bool {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv {
+            return false
+        }
+        if size[pu] >= size[pv] {
+            size[pu] += size[pv]
+            parent[pv] = pu
+        } else {
+            size[pv] += size[pu]
+            parent[pu] = pv
+        }
+        return true
+    }
+
+    func getSize(_ node: Int) -> Int {
+        let par = find(node)
+        return size[par]
+    }
+}
+
+class Solution {
+    func maxAreaOfIsland(_ grid: [[Int]]) -> Int {
+        var grid = grid
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        let dsu = DSU(ROWS * COLS)
+
+        func index(_ r: Int, _ c: Int) -> Int {
+            return r * COLS + c
+        }
+
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+        var area = 0
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == 1 {
+                    for dir in directions {
+                        let nr = r + dir.0
+                        let nc = c + dir.1
+                        if nr < 0 || nc < 0 || nr >= ROWS || nc >= COLS || grid[nr][nc] == 0 {
+                            continue
+                        }
+                        dsu.union(index(r, c), index(nr, nc))
+                    }
+                    area = max(area, dsu.getSize(index(r, c)))
+                }
+            }
+        }
+
+        return area
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/max-water-container.md b/articles/max-water-container.md
index dfd046f07..bb1ea6083 100644
--- a/articles/max-water-container.md
+++ b/articles/max-water-container.md
@@ -110,6 +110,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxArea(_ heights: [Int]) -> Int {
+        var res = 0
+        for i in 0..<heights.count {
+            for j in (i + 1)..<heights.count {
+                res = max(res, min(heights[i], heights[j]) * (j - i))
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -277,6 +291,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxArea(_ heights: [Int]) -> Int {
+        var l = 0, r = heights.count - 1
+        var res = 0
+
+        while l < r {
+            let area = min(heights[l], heights[r]) * (r - l)
+            res = max(res, area)
+            if heights[l] <= heights[r] {
+                l += 1
+            } else {
+                r -= 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/maximum-product-subarray.md b/articles/maximum-product-subarray.md
index 5f5f0e299..f163b341f 100644
--- a/articles/maximum-product-subarray.md
+++ b/articles/maximum-product-subarray.md
@@ -137,6 +137,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProduct(_ nums: [Int]) -> Int {
+        var res = nums[0]
+
+        for i in 0..<nums.count {
+            var cur = nums[i]
+            res = max(res, cur)
+            for j in (i + 1)..<nums.count {
+                cur *= nums[j]
+                res = max(res, cur)
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -496,6 +515,59 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProduct(_ nums: [Int]) -> Int {
+        var A = [[Int]]()
+        var cur = [Int]()
+        var res = Int.min
+
+        for num in nums {
+            res = max(res, num)
+            if num == 0 {
+                if !cur.isEmpty {
+                    A.append(cur)
+                }
+                cur = []
+            } else {
+                cur.append(num)
+            }
+        }
+
+        if !cur.isEmpty {
+            A.append(cur)
+        }
+
+        for sub in A {
+            let negsCount = sub.filter { $0 < 0 }.count
+            var prod = 1
+            var need = negsCount % 2 == 0 ? negsCount : negsCount - 1
+            var negs = 0
+            var j = 0
+
+            for i in 0..<sub.count {
+                prod *= sub[i]
+                if sub[i] < 0 {
+                    negs += 1
+                    while negs > need {
+                        prod /= sub[j]
+                        if sub[j] < 0 {
+                            negs -= 1
+                        }
+                        j += 1
+                    }
+                }
+                if j <= i {
+                    res = max(res, prod)
+                }
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -642,6 +714,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProduct(_ nums: [Int]) -> Int {
+        var res = nums[0]
+        var curMin = 1, curMax = 1
+
+        for num in nums {
+            let tmp = curMax * num
+            curMax = max(num * curMax, num * curMin, num)
+            curMin = min(tmp, num * curMin, num)
+            res = max(res, curMax)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -791,6 +880,23 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxProduct(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var res = nums[0]
+        var prefix = 0, suffix = 0
+
+        for i in 0..<n {
+            prefix = nums[i] * (prefix != 0 ? prefix : 1)
+            suffix = nums[n - 1 - i] * (suffix != 0 ? suffix : 1)
+            res = max(res, max(prefix, suffix))
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/maximum-subarray.md b/articles/maximum-subarray.md
index afdcd634f..678ab39c8 100644
--- a/articles/maximum-subarray.md
+++ b/articles/maximum-subarray.md
@@ -119,6 +119,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var res = nums[0]
+
+        for i in 0..<n {
+            var cur = 0
+            for j in i..<n {
+                cur += nums[j]
+                res = max(res, cur)
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -259,6 +278,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        func dfs(_ i: Int, _ flag: Bool) -> Int {
+            if i == nums.count {
+                return flag ? 0 : Int.min
+            }
+
+            if flag {
+                return max(0, nums[i] + dfs(i + 1, true))
+            }
+
+            return max(dfs(i + 1, false), nums[i] + dfs(i + 1, true))
+        }
+
+        return dfs(0, false)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -449,6 +488,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        var memo = Array(repeating: [Int?](repeating: nil, count: 2), count: nums.count + 1)
+
+        func dfs(_ i: Int, _ flag: Bool) -> Int {
+            if i == nums.count {
+                return flag ? 0 : Int.min
+            }
+            if let value = memo[i][flag ? 1 : 0] {
+                return value
+            }
+
+            if flag {
+                memo[i][flag ? 1 : 0] = max(0, nums[i] + dfs(i + 1, true))
+            } else {
+                memo[i][flag ? 1 : 0] = max(dfs(i + 1, false), nums[i] + dfs(i + 1, true))
+            }
+
+            return memo[i][flag ? 1 : 0]!
+        }
+
+        return dfs(0, false)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -594,6 +660,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var dp = Array(repeating: [0, 0], count: n)
+        dp[n - 1][1] = nums[n - 1]
+        dp[n - 1][0] = nums[n - 1]
+
+        for i in (0..<n-1).reversed() {
+            dp[i][1] = max(nums[i], nums[i] + dp[i + 1][1])
+            dp[i][0] = max(dp[i + 1][0], dp[i][1])
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -718,6 +802,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        var dp = nums
+
+        for i in 1..<nums.count {
+            dp[i] = max(nums[i], nums[i] + dp[i - 1])
+        }
+
+        return dp.max() ?? 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -851,6 +949,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        var maxSub = nums[0]
+        var curSum = 0
+
+        for num in nums {
+            if curSum < 0 {
+                curSum = 0
+            }
+            curSum += num
+            maxSub = max(maxSub, curSum)
+        }
+
+        return maxSub
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1092,6 +1209,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+
+        func dfs(_ l: Int, _ r: Int) -> Int {
+            if l > r {
+                return Int.min
+            }
+
+            let m = (l + r) / 2
+            var leftSum = 0
+            var rightSum = 0
+            var curSum = 0
+
+            for i in stride(from: m - 1, through: l, by: -1) {
+                curSum += nums[i]
+                leftSum = max(leftSum, curSum)
+            }
+
+            curSum = 0
+            for i in stride(from: m + 1, to: r + 1, by: 1) {
+                curSum += nums[i]
+                rightSum = max(rightSum, curSum)
+            }
+
+            return max(dfs(l, m - 1), dfs(m + 1, r), leftSum + nums[m] + rightSum)
+        }
+
+        return dfs(0, nums.count - 1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/median-of-two-sorted-arrays.md b/articles/median-of-two-sorted-arrays.md
index 6fb01b6af..3ac051111 100644
--- a/articles/median-of-two-sorted-arrays.md
+++ b/articles/median-of-two-sorted-arrays.md
@@ -127,6 +127,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
+        var merged = nums1 + nums2
+        merged.sort()
+        
+        let totalLen = merged.count
+        if totalLen % 2 == 0 {
+            return (Double(merged[totalLen / 2 - 1]) + Double(merged[totalLen / 2])) / 2.0
+        } else {
+            return Double(merged[totalLen / 2])
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -391,6 +407,41 @@ class Solution {
 }
 ```
 
+```kotlin
+class Solution {
+    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
+        let len1 = nums1.count, len2 = nums2.count
+        var i = 0, j = 0
+        var median1 = 0, median2 = 0
+
+        for _ in 0..<(len1 + len2) / 2 + 1 {
+            median2 = median1
+            if i < len1 && j < len2 {
+                if nums1[i] > nums2[j] {
+                    median1 = nums2[j]
+                    j += 1
+                } else {
+                    median1 = nums1[i]
+                    i += 1
+                }
+            } else if i < len1 {
+                median1 = nums1[i]
+                i += 1
+            } else {
+                median1 = nums2[j]
+                j += 1
+            }
+        }
+
+        if (len1 + len2) % 2 == 1 {
+            return Double(median1)
+        } else {
+            return (Double(median1) + Double(median2)) / 2.0
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -653,12 +704,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func getKth(_ a: [Int], _ m: Int, _ b: [Int], _ n: Int, _ k: Int, _ aStart: Int = 0, _ bStart: Int = 0) -> Int {
+        if m > n {
+            return getKth(b, n, a, m, k, bStart, aStart)
+        }
+        if m == 0 {
+            return b[bStart + k - 1]
+        }
+        if k == 1 {
+            return min(a[aStart], b[bStart])
+        }
+        
+        let i = min(m, k / 2)
+        let j = min(n, k / 2)
+        
+        if a[aStart + i - 1] > b[bStart + j - 1] {
+            return getKth(a, m, b, n - j, k - j, aStart, bStart + j)
+        } else {
+            return getKth(a, m - i, b, n, k - i, aStart + i, bStart)
+        }
+    }
+    
+    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
+        let left = (nums1.count + nums2.count + 1) / 2
+        let right = (nums1.count + nums2.count + 2) / 2
+        return (Double(getKth(nums1, nums1.count, nums2, nums2.count, left)) +
+                Double(getKth(nums1, nums1.count, nums2, nums2.count, right))) / 2.0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(\log (m + n))$
-* Space complexity: $O(\log (m + n))$
+* Space complexity: $O(\log (m + n))$ for recursion stack.
 
 > Where $n$ is the length of $nums1$ and $m$ is the length of $nums2$.
 
@@ -969,6 +1052,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
+        var A = nums1, B = nums2
+        if A.count > B.count {
+            swap(&A, &B)
+        }
+
+        let total = A.count + B.count
+        let half = total / 2
+        var l = 0
+        var r = A.count
+
+        while true {
+            let i = (l + r) / 2
+            let j = half - i
+
+            let Aleft = i > 0 ? Double(A[i - 1]) : -Double.infinity
+            let Aright = i < A.count ? Double(A[i]) : Double.infinity
+            let Bleft = j > 0 ? Double(B[j - 1]) : -Double.infinity
+            let Bright = j < B.count ? Double(B[j]) : Double.infinity
+
+            if Aleft <= Bright && Bleft <= Aright {
+                if total % 2 == 1 {
+                    return min(Aright, Bright)
+                } else {
+                    return (max(Aleft, Bleft) + min(Aright, Bright)) / 2.0
+                }
+            } else if Aleft > Bright {
+                r = i - 1
+            } else {
+                l = i + 1
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/meeting-schedule-ii.md b/articles/meeting-schedule-ii.md
index ce53b1e92..afd50a48e 100644
--- a/articles/meeting-schedule-ii.md
+++ b/articles/meeting-schedule-ii.md
@@ -193,6 +193,34 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition of Interval:
+ * class Interval {
+ *     var start: Int
+ *     var end: Int
+ *     init(start: Int, end: Int) {
+ *         self.start = start
+ *         self.end = end
+ *     }
+ * }
+ */
+
+class Solution {
+    func minMeetingRooms(_ intervals: [Interval]) -> Int {
+        let sortedIntervals = intervals.sorted { $0.start < $1.start }
+        var minHeap = Heap<Int>()
+        for interval in sortedIntervals {
+            if !minHeap.isEmpty, let earliest = minHeap.min!, earliest <= interval.start {
+                minHeap.removeMin()
+            }
+            minHeap.insert(interval.end)
+        }
+        return minHeap.count
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -414,6 +442,37 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition of Interval:
+ * class Interval {
+ *     var start: Int
+ *     var end: Int
+ *     init(start: Int, end: Int) {
+ *         self.start = start
+ *         self.end = end
+ *     }
+ * }
+ */
+
+class Solution {
+    func minMeetingRooms(_ intervals: [Interval]) -> Int {
+        var mp = [Int: Int]()
+        for interval in intervals {
+            mp[interval.start, default: 0] += 1
+            mp[interval.end, default: 0] -= 1
+        }
+        var prev = 0
+        var res = 0
+        for key in mp.keys.sorted() {
+            prev += mp[key]!
+            res = max(res, prev)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -689,6 +748,40 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition of Interval:
+ * class Interval {
+ *     var start: Int
+ *     var end: Int
+ *     init(start: Int, end: Int) {
+ *         self.start = start
+ *         self.end = end
+ *     }
+ * }
+ */
+
+class Solution {
+    func minMeetingRooms(_ intervals: [Interval]) -> Int {
+        let starts = intervals.map { $0.start }.sorted()
+        let ends = intervals.map { $0.end }.sorted()
+        
+        var res = 0, count = 0, s = 0, e = 0
+        while s < intervals.count {
+            if starts[s] < ends[e] {
+                count += 1
+                s += 1
+            } else {
+                count -= 1
+                e += 1
+            }
+            res = max(res, count)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -929,6 +1022,47 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition of Interval:
+ * class Interval {
+ *     var start: Int
+ *     var end: Int
+ *     init(start: Int, end: Int) {
+ *         self.start = start
+ *         self.end = end
+ *     }
+ * }
+ */
+
+class Solution {
+    func minMeetingRooms(_ intervals: [Interval]) -> Int {
+        var times = [(Int, Int)]()
+        for interval in intervals {
+            times.append((interval.start, 1))
+            times.append((interval.end, -1))
+        }
+
+        times.sort { 
+            if $0.0 != $1.0 {
+                return $0.0 < $1.0
+            } else {
+                return $0.1 < $1.1
+            }
+        }
+
+        var count = 0
+        var res = 0
+        for t in times {
+            count += t.1
+            res = max(res, count)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/meeting-schedule.md b/articles/meeting-schedule.md
index 735df876a..226a6a70f 100644
--- a/articles/meeting-schedule.md
+++ b/articles/meeting-schedule.md
@@ -205,6 +205,36 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition of Interval:
+ * class Interval {
+ *     var start: Int
+ *     var end: Int
+ *     init(start: Int, end: Int) {
+ *         self.start = start
+ *         self.end = end
+ *     }
+ * }
+ */
+
+class Solution {
+    func canAttendMeetings(_ intervals: [Interval]) -> Bool {
+        let n = intervals.count
+        for i in 0..<n {
+            let A = intervals[i]
+            for j in (i + 1)..<n {
+                let B = intervals[j]
+                if min(A.end, B.end) > max(A.start, B.start) {
+                    return false
+                }
+            }
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -400,6 +430,32 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition of Interval:
+ * class Interval {
+ *     var start: Int
+ *     var end: Int
+ *     init(start: Int, end: Int) {
+ *         self.start = start
+ *         self.end = end
+ *     }
+ * }
+ */
+
+class Solution {
+    func canAttendMeetings(_ intervals: [Interval]) -> Bool {
+        let sortedIntervals = intervals.sorted { $0.start < $1.start }
+        for i in 1..<sortedIntervals.count {
+            if sortedIntervals[i - 1].end > sortedIntervals[i].start {
+                return false
+            }
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/merge-intervals.md b/articles/merge-intervals.md
index 4ff97b569..100d894b6 100644
--- a/articles/merge-intervals.md
+++ b/articles/merge-intervals.md
@@ -164,6 +164,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func merge(_ intervals: [[Int]]) -> [[Int]] {
+        let intervals = intervals.sorted { $0[0] < $1[0] }
+        var output: [[Int]] = [intervals[0]]
+
+        for interval in intervals {
+            let start = interval[0]
+            let end = interval[1]
+            var lastEnd = output.last![1]
+
+            if start <= lastEnd {
+                output[output.count - 1][1] = max(lastEnd, end)
+            } else {
+                output.append([start, end])
+            }
+        }
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -383,6 +405,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func merge(_ intervals: [[Int]]) -> [[Int]] {
+        var mp = [Int: Int]()
+        
+        for interval in intervals {
+            let start = interval[0]
+            let end = interval[1]
+            mp[start, default: 0] += 1
+            mp[end, default: 0] -= 1
+        }
+
+        var res = [[Int]]()
+        var interval = [Int]()
+        var have = 0
+
+        for i in mp.keys.sorted() {
+            if interval.isEmpty {
+                interval.append(i)
+            }
+            have += mp[i, default: 0]
+            if have == 0 {
+                interval.append(i)
+                res.append(interval)
+                interval = []
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -678,6 +732,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func merge(_ intervals: [[Int]]) -> [[Int]] {
+        let maxVal = intervals.map { $0[0] }.max() ?? 0
+        var mp = [Int](repeating: 0, count: maxVal + 1)
+        for interval in intervals {
+            let start = interval[0]
+            let end = interval[1]
+            mp[start] = max(end + 1, mp[start])
+        }
+
+        var res = [[Int]]()
+        var have = -1
+        var intervalStart = -1
+
+        for i in 0..<mp.count {
+            if mp[i] != 0 {
+                if intervalStart == -1 {
+                    intervalStart = i
+                }
+                have = max(mp[i] - 1, have)
+            }
+            if have == i {
+                res.append([intervalStart, have])
+                have = -1
+                intervalStart = -1
+            }
+        }
+
+        if intervalStart != -1 {
+            res.append([intervalStart, have])
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/merge-k-sorted-linked-lists.md b/articles/merge-k-sorted-linked-lists.md
index fd102df3f..6150fa6f5 100644
--- a/articles/merge-k-sorted-linked-lists.md
+++ b/articles/merge-k-sorted-linked-lists.md
@@ -238,6 +238,43 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
+        var nodes: [Int] = []
+
+        for list in lists {
+            var lst = list
+            while lst != nil {
+                nodes.append(lst!.val)
+                lst = lst?.next
+            }
+        }
+
+        nodes.sort()
+
+        let dummy = ListNode(0)
+        var cur = dummy
+        for node in nodes {
+            cur.next = ListNode(node)
+            cur = cur.next!
+        }
+
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -510,6 +547,47 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
+        var lists = lists
+        let dummy = ListNode(0)
+        var cur = dummy
+
+        while true {
+            var minNodeIndex: Int? = nil
+            for i in 0..<lists.count {
+                if let node = lists[i] {
+                    if minNodeIndex == nil || node.val < lists[minNodeIndex!]?.val ?? Int.max {
+                        minNodeIndex = i
+                    }
+                }
+            }
+
+            if minNodeIndex == nil {
+                break
+            }
+            
+            cur.next = lists[minNodeIndex!]
+            lists[minNodeIndex!] = lists[minNodeIndex!]?.next
+            cur = cur.next!
+        }
+
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -862,6 +940,59 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
+        if lists.isEmpty {
+            return nil
+        }
+
+        var lists = lists
+        for i in 1..<lists.count {
+            lists[i] = mergeList(lists[i - 1], lists[i])
+        }
+
+        return lists.last!
+    }
+
+    private func mergeList(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
+        let dummy = ListNode(0)
+        var tail = dummy
+        var l1 = l1, l2 = l2
+
+        while l1 != nil && l2 != nil {
+            if l1!.val < l2!.val {
+                tail.next = l1
+                l1 = l1?.next
+            } else {
+                tail.next = l2
+                l2 = l2?.next
+            }
+            tail = tail.next!
+        }
+
+        if l1 != nil {
+            tail.next = l1
+        }
+        if l2 != nil {
+            tail.next = l2
+        }
+        
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1157,6 +1288,60 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+struct NodeWrapper: Comparable {
+    let node: ListNode
+
+    init(_ node: ListNode) {
+        self.node = node
+    }
+
+    static func < (lhs: NodeWrapper, rhs: NodeWrapper) -> Bool {
+        return lhs.node.val < rhs.node.val
+    }
+
+    static func == (lhs: NodeWrapper, rhs: NodeWrapper) -> Bool {
+        return lhs.node.val == rhs.node.val
+    }
+}
+
+class Solution {
+    func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
+        var heap = Heap<NodeWrapper>()
+
+        for list in lists {
+            if let node = list {
+                heap.insert(NodeWrapper(node))
+            }
+        }
+
+        let dummy = ListNode(0)
+        var tail = dummy
+
+        while let wrapper = heap.popMin() {
+            tail.next = wrapper.node
+            tail = tail.next!
+
+            if let next = wrapper.node.next {
+                heap.insert(NodeWrapper(next))
+            }
+        }
+
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1190,14 +1375,17 @@ class Solution:
             return None
         if l == r:
             return lists[l]
+
         mid = l + (r - l) // 2
         left = self.divide(lists, l, mid)
         right = self.divide(lists, mid + 1, r)
+
         return self.conquer(left, right)
 
     def conquer(self, l1, l2):
         dummy = ListNode(0)
         curr = dummy
+
         while l1 and l2:
             if l1.val <= l2.val:
                 curr.next = l1
@@ -1206,10 +1394,12 @@ class Solution:
                 curr.next = l2
                 l2 = l2.next
             curr = curr.next
+
         if l1:
             curr.next = l1
         else:
             curr.next = l2
+
         return dummy.next
 ```
 
@@ -1240,9 +1430,11 @@ class Solution {
         if (l == r) {
             return lists[l];
         }
+
         int mid = l + (r - l) / 2; 
         ListNode left = divide(lists, l, mid);
         ListNode right = divide(lists, mid + 1, r);
+
         return conquer(left, right);
     }
 
@@ -1302,15 +1494,18 @@ private:
         if (l == r) {
             return lists[l];
         }
+
         int mid = l + (r - l) / 2;
         ListNode* left = divide(lists, l, mid);
         ListNode* right = divide(lists, mid + 1, r);
+
         return conquer(left, right);
     }
 
     ListNode* conquer(ListNode* l1, ListNode* l2) {
         ListNode dummy(0);
         ListNode* curr = &dummy;
+
         while (l1 && l2) {
             if (l1->val <= l2->val) {
                 curr->next = l1;
@@ -1321,11 +1516,13 @@ private:
             }
             curr = curr->next;
         }
+
         if (l1) {
             curr->next = l1;
         } else {
             curr->next = l2;
         }
+
         return dummy.next;
     }
 };
@@ -1367,9 +1564,11 @@ class Solution {
         if (l === r) {
             return lists[l];
         }
+
         const mid = Math.floor(l + (r - l) / 2);
         const left = this.divide(lists, l, mid);
         const right = this.divide(lists, mid + 1, r);
+
         return this.conquer(left, right);
     }
 
@@ -1381,6 +1580,7 @@ class Solution {
     conquer(l1, l2) {
         const dummy = new ListNode(0);
         let curr = dummy;
+
         while (l1 && l2) {
             if (l1.val <= l2.val) {
                 curr.next = l1;
@@ -1391,6 +1591,7 @@ class Solution {
             }
             curr = curr.next;
         }
+
         curr.next = l1 ? l1 : l2;
         return dummy.next;
     }
@@ -1425,9 +1626,11 @@ public class Solution {
         if (l == r) {
             return lists[l];
         }
+
         int mid = l + (r - l) / 2;
         ListNode left = Divide(lists, l, mid);
         ListNode right = Divide(lists, mid + 1, r);
+
         return Conquer(left, right);
     }
 
@@ -1479,15 +1682,18 @@ func divide(lists []*ListNode, left, right int) *ListNode {
     if left == right {
         return lists[left]
     }
+
     mid := left + (right-left)/2
     l1 := divide(lists, left, mid)
     l2 := divide(lists, mid+1, right)
+
     return conquer(l1, l2)
 }
 
 func conquer(l1, l2 *ListNode) *ListNode {
     dummy := &ListNode{}
     curr := dummy
+
     for l1 != nil && l2 != nil {
         if l1.Val <= l2.Val {
             curr.Next = l1
@@ -1498,11 +1704,13 @@ func conquer(l1, l2 *ListNode) *ListNode {
         }
         curr = curr.Next
     }
+
     if l1 != nil {
         curr.Next = l1
     } else {
         curr.Next = l2
     }
+
     return dummy.Next
 }
 ```
@@ -1526,9 +1734,11 @@ class Solution {
     private fun divide(lists: Array<ListNode?>, left: Int, right: Int): ListNode? {
         if (left > right) return null
         if (left == right) return lists[left]
+
         val mid = left + (right - left) / 2
         val l1 = divide(lists, left, mid)
         val l2 = divide(lists, mid + 1, right)
+
         return conquer(l1, l2)
     }
 
@@ -1537,6 +1747,7 @@ class Solution {
         var curr = dummy
         var list1 = l1
         var list2 = l2
+
         while (list1 != null && list2 != null) {
             if (list1.`val` <= list2.`val`) {
                 curr.next = list1
@@ -1547,12 +1758,68 @@ class Solution {
             }
             curr = curr.next!!
         }
+
         curr.next = list1 ?: list2
         return dummy.next
     }
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
+        if lists.isEmpty {
+            return nil
+        }
+        return divide(lists, 0, lists.count - 1)
+    }
+
+    private func divide(_ lists: [ListNode?], _ l: Int, _ r: Int) -> ListNode? {
+        if l > r {
+            return nil
+        }
+        if l == r {
+            return lists[l]
+        }
+        
+        let mid = l + (r - l) / 2
+        let left = divide(lists, l, mid)
+        let right = divide(lists, mid + 1, r)
+        return conquer(left, right)
+    }
+
+    private func conquer(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
+        let dummy = ListNode(0)
+        var curr = dummy
+        var l1 = l1, l2 = l2
+
+        while let node1 = l1, let node2 = l2 {
+            if node1.val <= node2.val {
+                curr.next = node1
+                l1 = node1.next
+            } else {
+                curr.next = node2
+                l2 = node2.next
+            }
+            curr = curr.next!
+        }
+
+        curr.next = l1 ?? l2
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1602,10 +1869,12 @@ class Solution:
                 tail.next = l2
                 l2 = l2.next
             tail = tail.next
+
         if l1:
             tail.next = l1
         if l2:
             tail.next = l2
+
         return dummy.next
 ```
 
@@ -1653,12 +1922,14 @@ public class Solution {
             }
             tail = tail.next;
         }
+
         if (l1 != null) {
             tail.next = l1;
         }
         if (l2 != null) {
             tail.next = l2;
         }
+
         return dummy.next;
     }
 }
@@ -1710,12 +1981,14 @@ private:
             }
             tail = tail->next;
         }
+
         if (l1) {
             tail->next = l1;
         }
         if (l2) {
             tail->next = l2;
         }
+
         return dummy.next;
     }
 };
@@ -1762,6 +2035,7 @@ class Solution {
     mergeList(l1, l2) {
         const dummy = new ListNode(0);
         let curr = dummy;
+
         while (l1 && l2) {
             if (l1.val <= l2.val) {
                 curr.next = l1;
@@ -1772,6 +2046,7 @@ class Solution {
             }
             curr = curr.next;
         }
+
         curr.next = l1 ? l1 : l2;
         return dummy.next;
     }
@@ -1823,12 +2098,14 @@ public class Solution {
             }
             tail = tail.next;
         }
+
         if (l1 != null) {
             tail.next = l1;
         }
         if (l2 != null) {
             tail.next = l2;
         }
+
         return dummy.next;
     }
 }
@@ -1876,11 +2153,13 @@ func mergeList(l1, l2 *ListNode) *ListNode {
         }
         tail = tail.Next
     }
+
     if l1 != nil {
         tail.Next = l1
     } else {
         tail.Next = l2
     }
+
     return dummy.Next
 }
 ```
@@ -1928,12 +2207,69 @@ class Solution {
             }
             tail = tail.next!!
         }
+
         tail.next = list1 ?: list2
         return dummy.next
     }
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
+        if lists.isEmpty {
+            return nil
+        }
+        
+        var lists = lists
+        
+        while lists.count > 1 {
+            var mergedLists: [ListNode?] = []
+            
+            for i in stride(from: 0, to: lists.count, by: 2) {
+                let l1 = lists[i]
+                let l2 = i + 1 < lists.count ? lists[i + 1] : nil
+                mergedLists.append(mergeList(l1, l2))
+            }
+            
+            lists = mergedLists
+        }
+        
+        return lists[0]
+    }
+
+    private func mergeList(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
+        let dummy = ListNode(0)
+        var tail = dummy
+        var l1 = l1, l2 = l2
+
+        while let node1 = l1, let node2 = l2 {
+            if node1.val < node2.val {
+                tail.next = node1
+                l1 = node1.next
+            } else {
+                tail.next = node2
+                l2 = node2.next
+            }
+            tail = tail.next!
+        }
+
+        tail.next = l1 ?? l2
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/merge-triplets-to-form-target.md b/articles/merge-triplets-to-form-target.md
index 4fe080b4c..268d8ae9d 100644
--- a/articles/merge-triplets-to-form-target.md
+++ b/articles/merge-triplets-to-form-target.md
@@ -138,6 +138,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func mergeTriplets(_ triplets: [[Int]], _ target: [Int]) -> Bool {
+        var good = Set<Int>()
+
+        for t in triplets {
+            if t[0] > target[0] || t[1] > target[1] || t[2] > target[2] {
+                continue
+            }
+            for (i, v) in t.enumerated() {
+                if v == target[i] {
+                    good.insert(i)
+                }
+            }
+        }
+
+        return good.count == 3
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -268,6 +289,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func mergeTriplets(_ triplets: [[Int]], _ target: [Int]) -> Bool {
+        var x = false, y = false, z = false
+
+        for t in triplets {
+            if t[0] <= target[0] && t[1] <= target[1] && t[2] <= target[2] {
+                if t[0] == target[0] { x = true }
+                if t[1] == target[1] { y = true }
+                if t[2] == target[2] { z = true }
+            }
+
+            if x && y && z {
+                return true
+            }
+        }
+
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/merge-two-sorted-linked-lists.md b/articles/merge-two-sorted-linked-lists.md
index bffc3e16f..b65407ade 100644
--- a/articles/merge-two-sorted-linked-lists.md
+++ b/articles/merge-two-sorted-linked-lists.md
@@ -203,6 +203,36 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeTwoLists(_ list1: ListNode?, _ list2: ListNode?) -> ListNode? {
+        if list1 == nil {
+            return list2
+        }
+        if list2 == nil {
+            return list1
+        }
+        if list1!.val <= list2!.val {
+            list1!.next = mergeTwoLists(list1!.next, list2)
+            return list1
+        } else {
+            list2!.next = mergeTwoLists(list1, list2!.next)
+            return list2
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -473,6 +503,42 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func mergeTwoLists(_ list1: ListNode?, _ list2: ListNode?) -> ListNode? {
+        let dummy = ListNode(0)
+        var node = dummy
+        var l1 = list1
+        var l2 = list2
+
+        while l1 != nil && l2 != nil {
+            if l1!.val < l2!.val {
+                node.next = l1
+                l1 = l1?.next
+            } else {
+                node.next = l2
+                l2 = l2?.next
+            }
+            node = node.next!
+        }
+
+        node.next = l1 ?? l2
+
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/min-cost-climbing-stairs.md b/articles/min-cost-climbing-stairs.md
index 3c7139726..9433d007b 100644
--- a/articles/min-cost-climbing-stairs.md
+++ b/articles/min-cost-climbing-stairs.md
@@ -118,6 +118,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minCostClimbingStairs(_ cost: [Int]) -> Int {
+        func dfs(_ i: Int) -> Int {
+            if i >= cost.count {
+                return 0
+            }
+            return cost[i] + min(dfs(i + 1), dfs(i + 2))
+        }
+
+        return min(dfs(0), dfs(1))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -291,6 +306,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minCostClimbingStairs(_ cost: [Int]) -> Int {
+        var memo = Array(repeating: -1, count: cost.count)
+
+        func dfs(_ i: Int) -> Int {
+            if i >= cost.count {
+                return 0
+            }
+            if memo[i] != -1 {
+                return memo[i]
+            }
+            memo[i] = cost[i] + min(dfs(i + 1), dfs(i + 2))
+            return memo[i]
+        }
+
+        return min(dfs(0), dfs(1))
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -423,6 +459,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minCostClimbingStairs(_ cost: [Int]) -> Int {
+        let n = cost.count
+        var dp = Array(repeating: 0, count: n + 1)
+
+        for i in 2...n {
+            dp[i] = min(dp[i - 1] + cost[i - 1], 
+                        dp[i - 2] + cost[i - 2])
+        }
+
+        return dp[n]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -523,6 +575,17 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minCostClimbingStairs(_ cost: inout [Int]) -> Int {
+        for i in stride(from: cost.count - 3, through: 0, by: -1) {
+            cost[i] += min(cost[i + 1], cost[i + 2])
+        }
+        return min(cost[0], cost[1])
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/min-cost-to-connect-points.md b/articles/min-cost-to-connect-points.md
index 8e9e5226a..6688ee3a1 100644
--- a/articles/min-cost-to-connect-points.md
+++ b/articles/min-cost-to-connect-points.md
@@ -45,7 +45,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     int[] Parent, Size;
 
     public DSU(int n) {
@@ -398,6 +398,68 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    private var parent: [Int]
+    private var size: [Int]
+
+    init(_ n: Int) {
+        parent = Array(0...n)
+        size = Array(repeating: 1, count: n + 1)
+    }
+
+    func find(_ node: Int) -> Int {
+        if parent[node] != node {
+            parent[node] = find(parent[node])
+        }
+        return parent[node]
+    }
+
+    func union(_ u: Int, _ v: Int) -> Bool {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv {
+            return false
+        }
+        if size[pu] < size[pv] {
+            parent[pu] = pv
+            size[pv] += size[pu]
+        } else {
+            parent[pv] = pu
+            size[pu] += size[pv]
+        }
+        return true
+    }
+}
+
+class Solution {
+    func minCostConnectPoints(_ points: [[Int]]) -> Int {
+        let n = points.count
+        let dsu = DSU(n)
+        var edges = [(Int, Int, Int)]()
+
+        for i in 0..<n {
+            let x1 = points[i][0], y1 = points[i][1]
+            for j in i + 1..<n {
+                let x2 = points[j][0], y2 = points[j][1]
+                let dist = abs(x1 - x2) + abs(y1 - y2)
+                edges.append((dist, i, j))
+            }
+        }
+
+        edges.sort { $0.0 < $1.0 }
+        var res = 0
+
+        for (dist, u, v) in edges {
+            if dsu.union(u, v) {
+                res += dist
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -710,6 +772,62 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let cost: Int
+    let node: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.cost < rhs.cost
+    }
+}
+
+class Solution {
+    func minCostConnectPoints(_ points: [[Int]]) -> Int {
+        let N = points.count
+        var adj = [Int: [(Int, Int)]]()
+
+        for i in 0..<N {
+            let x1 = points[i][0], y1 = points[i][1]
+            for j in i + 1..<N {
+                let x2 = points[j][0], y2 = points[j][1]
+                let dist = abs(x1 - x2) + abs(y1 - y2)
+                adj[i, default: []].append((dist, j))
+                adj[j, default: []].append((dist, i))
+            }
+        }
+
+        var res = 0
+        var visit = Set<Int>()
+        var minHeap = Heap<Item>()
+        minHeap.insert(Item(cost: 0, node: 0))
+
+        while visit.count < N {
+            guard let item = minHeap.popMin() else { break }
+            let cost = item.cost
+            let i = item.node
+
+            if visit.contains(i) {
+                continue
+            }
+
+            res += cost
+            visit.insert(i)
+
+            if let neighbors = adj[i] {
+                for (neiCost, nei) in neighbors {
+                    if !visit.contains(nei) {
+                        minHeap.insert(Item(cost: neiCost, node: nei))
+                    }
+                }
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -940,6 +1058,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minCostConnectPoints(_ points: [[Int]]) -> Int {
+        let n = points.count
+        var node = 0
+        var dist = Array(repeating: 100000000, count: n)
+        var visit = Array(repeating: false, count: n)
+        var edges = 0
+        var res = 0
+
+        while edges < n - 1 {
+            visit[node] = true
+            var nextNode = -1
+
+            for i in 0..<n {
+                if visit[i] {
+                    continue
+                }
+                let curDist = abs(points[i][0] - points[node][0]) + 
+                              abs(points[i][1] - points[node][1])
+                dist[i] = min(dist[i], curDist)
+                if nextNode == -1 || dist[i] < dist[nextNode] {
+                    nextNode = i
+                }
+            }
+
+            res += dist[nextNode]
+            node = nextNode
+            edges += 1
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/minimum-interval-including-query.md b/articles/minimum-interval-including-query.md
index cd76921c2..3c1cf82d5 100644
--- a/articles/minimum-interval-including-query.md
+++ b/articles/minimum-interval-including-query.md
@@ -149,12 +149,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minInterval(_ intervals: [[Int]], _ queries: [Int]) -> [Int] {
+        var res = [Int]()
+
+        for q in queries {
+            var cur = -1
+            for interval in intervals {
+                let l = interval[0]
+                let r = interval[1]
+
+                if l <= q && q <= r {
+                    if cur == -1 || (r - l + 1) < cur {
+                        cur = r - l + 1
+                    }
+                }
+            }
+            res.append(cur)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(m * n)$
-* Space complexity: $O(1)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(m)$ space for the output array.
 
 > Where $m$ is the length of the array $queries$ and $n$ is the length of the array $intervals$.
 
@@ -508,6 +535,78 @@ class Solution {
 }
 ```
 
+```swift
+struct Event {
+    let time: Int
+    let type: Int    // 0: interval start, 1: query, 2: interval end
+    let size: Int?   // interval size for start/end events
+    let idx: Int?    // index for interval (for start/end) or query index (for query)
+}
+
+struct Item: Comparable {
+    let size: Int
+    let idx: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.size < rhs.size
+    }
+}
+
+class Solution {
+    func minInterval(_ intervals: [[Int]], _ queries: [Int]) -> [Int] {
+        var events = [Event]()
+        
+        // Create events for intervals
+        for (idx, interval) in intervals.enumerated() {
+            let start = interval[0]
+            let end = interval[1]
+            let intervalSize = end - start + 1
+            events.append(Event(time: start, type: 0, size: intervalSize, idx: idx))
+            events.append(Event(time: end, type: 2, size: intervalSize, idx: idx))
+        }
+        
+        // Create events for queries
+        for (i, q) in queries.enumerated() {
+            events.append(Event(time: q, type: 1, size: nil, idx: i))
+        }
+        
+        // Sort by time and type (end before query)
+        events.sort { (a, b) in
+            if a.time != b.time {
+                return a.time < b.time
+            }
+            return a.type < b.type
+        }
+        
+        // Min heap storing [size, index]
+        var sizes = Heap<Item>()
+        var ans = Array(repeating: -1, count: queries.count)
+        var inactive = Array(repeating: false, count: intervals.count)
+        
+        for event in events {
+            if event.type == 0 {  // Interval start
+                let intervalSize = event.size!
+                let idx = event.idx!
+                sizes.insert(Item(size: intervalSize, idx: idx))
+            } else if event.type == 2 { // Interval end
+                let idx = event.idx!
+                inactive[idx] = true
+            } else { // Query
+                let queryIdx = event.idx!
+                while !sizes.isEmpty, inactive[sizes.min!.idx] {
+                    sizes.removeMin()
+                }
+                if !sizes.isEmpty {
+                    ans[queryIdx] = sizes.min!.size
+                }
+            }
+        }
+        
+        return ans
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -779,6 +878,44 @@ class Solution {
 }
 ```
 
+```swift
+struct HeapItem: Comparable {
+    let size: Int
+    let end: Int
+    static func < (lhs: HeapItem, rhs: HeapItem) -> Bool {
+        if lhs.size == rhs.size {
+            return lhs.end < rhs.end
+        }
+        return lhs.size < rhs.size
+    }
+}
+
+class Solution {
+    func minInterval(_ intervals: [[Int]], _ queries: [Int]) -> [Int] {
+        let sortedIntervals = intervals.sorted { $0[0] < $1[0] }
+        var minHeap = Heap<HeapItem>()
+        var res = [Int: Int]()
+        var i = 0
+
+        for q in queries.sorted() {
+            while i < sortedIntervals.count && sortedIntervals[i][0] <= q {
+                let l = sortedIntervals[i][0]
+                let r = sortedIntervals[i][1]
+                minHeap.insert(HeapItem(size: r - l + 1, end: r))
+                i += 1
+            }
+
+            while !minHeap.isEmpty, minHeap.min!.end < q {
+                minHeap.removeMin()
+            }
+            res[q] = minHeap.isEmpty ? -1 : minHeap.min!.size
+        }
+
+        return queries.map { res[$0] ?? -1 }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -871,7 +1008,7 @@ class Solution:
 ```
 
 ```java
-public class SegmentTree {
+class SegmentTree {
     int n;
     int[] tree;
     int[] lazy;
@@ -1471,11 +1608,120 @@ class Solution {
 }
 ```
 
+```swift
+class SegmentTree {
+    let n: Int
+    var tree: [Int]
+    var lazy: [Int]
+    let INF = Int.max
+
+    init(_ N: Int) {
+        self.n = N
+        self.tree = [Int](repeating: INF, count: 4 * N)
+        self.lazy = [Int](repeating: INF, count: 4 * N)
+    }
+
+    // Propagate lazy value at tree index over range [lo, hi]
+    func propagate(_ treeidx: Int, _ lo: Int, _ hi: Int) {
+        if lazy[treeidx] != INF {
+            tree[treeidx] = min(tree[treeidx], lazy[treeidx])
+            if lo != hi {
+                lazy[2 * treeidx + 1] = min(lazy[2 * treeidx + 1], lazy[treeidx])
+                lazy[2 * treeidx + 2] = min(lazy[2 * treeidx + 2], lazy[treeidx])
+            }
+            lazy[treeidx] = INF
+        }
+    }
+
+    // Update the segment tree over range [left, right] with value val
+    func update(_ treeidx: Int, _ lo: Int, _ hi: Int, _ left: Int, _ right: Int, _ val: Int) {
+        propagate(treeidx, lo, hi)
+        if lo > right || hi < left {
+            return
+        }
+        if lo >= left && hi <= right {
+            lazy[treeidx] = min(lazy[treeidx], val)
+            propagate(treeidx, lo, hi)
+            return
+        }
+        let mid = (lo + hi) / 2
+        update(2 * treeidx + 1, lo, mid, left, right, val)
+        update(2 * treeidx + 2, mid + 1, hi, left, right, val)
+        tree[treeidx] = min(tree[2 * treeidx + 1], tree[2 * treeidx + 2])
+    }
+
+    // Query the value at index idx in the original array
+    func query(_ treeidx: Int, _ lo: Int, _ hi: Int, _ idx: Int) -> Int {
+        propagate(treeidx, lo, hi)
+        if lo == hi {
+            return tree[treeidx]
+        }
+        let mid = (lo + hi) / 2
+        if idx <= mid {
+            return query(2 * treeidx + 1, lo, mid, idx)
+        } else {
+            return query(2 * treeidx + 2, mid + 1, hi, idx)
+        }
+    }
+
+    func update_range(_ left: Int, _ right: Int, _ val: Int) {
+        update(0, 0, n - 1, left, right, val)
+    }
+
+    func query_point(_ idx: Int) -> Int {
+        return query(0, 0, n - 1, idx)
+    }
+}
+
+class Solution {
+    func minInterval(_ intervals: [[Int]], _ queries: [Int]) -> [Int] {
+        var points = [Int]()
+        // Create events for intervals
+        for interval in intervals {
+            points.append(interval[0])
+            points.append(interval[1])
+        }
+        // Create events for queries
+        for q in queries {
+            points.append(q)
+        }
+        
+        // Compress the coordinates
+        let sortedPoints = Array(Set(points)).sorted()
+        var compress = [Int: Int]()
+        for (i, point) in sortedPoints.enumerated() {
+            compress[point] = i
+        }
+
+        // Lazy Segment Tree
+        let segTree = SegmentTree(sortedPoints.count)
+
+        for interval in intervals {
+            let start = compress[interval[0]]!
+            let end = compress[interval[1]]!
+            let length = interval[1] - interval[0] + 1
+            segTree.update_range(start, end, length)
+        }
+
+        var ans = [Int]()
+        for q in queries {
+            let idx = compress[q]!
+            // Query for minSize
+            let res = segTree.query_point(idx)
+            ans.append(res == segTree.INF ? -1 : res)
+        }
+        return ans
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O((n + m)\log k)$
-* Space complexity: $O(k)$
+* Space complexity:
+    * $O(k)$ extra space.
+    * $O(m)$ space for the output array.
 
 > Where $m$ is the length of the array $queries$, $n$ is the length of the array $intervals$ and $k$ is the number of unique points.
\ No newline at end of file
diff --git a/articles/minimum-stack.md b/articles/minimum-stack.md
index 28527e995..29041a02c 100644
--- a/articles/minimum-stack.md
+++ b/articles/minimum-stack.md
@@ -278,6 +278,42 @@ class MinStack() {
 }
 ```
 
+```swift
+class MinStack {
+    private var stack: [Int] = []
+
+    init() {}
+
+    func push(_ val: Int) {
+        stack.append(val)
+    }
+
+    func pop() {
+        stack.popLast()
+    }
+
+    func top() -> Int {
+        return stack.last!
+    }
+
+    func getMin() -> Int {
+        var tmp = [Int]()
+        var mini = stack.last!
+
+        while !stack.isEmpty {
+            mini = min(mini, stack.last!)
+            tmp.append(stack.removeLast())
+        }
+
+        while !tmp.isEmpty {
+            stack.append(tmp.removeLast())
+        }
+
+        return mini
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -524,6 +560,34 @@ class MinStack() {
 }
 ```
 
+```swift
+class MinStack {
+    private var stack: [Int] = []
+    private var minStack: [Int] = []
+
+    init() {}
+
+    func push(_ val: Int) {
+        stack.append(val)
+        let minVal = min(val, minStack.last ?? val)
+        minStack.append(minVal)
+    }
+
+    func pop() {
+        stack.popLast()
+        minStack.popLast()
+    }
+
+    func top() -> Int {
+        return stack.last!
+    }
+
+    func getMin() -> Int {
+        return minStack.last!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -543,14 +607,14 @@ class MinStack:
         self.min = float('inf')
         self.stack = []
 
-    def push(self, x: int) -> None:
+    def push(self, val: int) -> None:
         if not self.stack:
             self.stack.append(0)
-            self.min = x
+            self.min = val
         else:
-            self.stack.append(x - self.min)
-            if x < self.min:
-                self.min = x
+            self.stack.append(val - self.min)
+            if val < self.min:
+                self.min = val
 
     def pop(self) -> None:
         if not self.stack:
@@ -581,13 +645,13 @@ public class MinStack {
         stack = new Stack<>();
     }
     
-    public void push(int x) {
+    public void push(int val) {
         if (stack.isEmpty()) {
             stack.push(0L);
-            min = x;
+            min = val;
         } else {
-            stack.push(x - min);
-            if (x < min) min = x;
+            stack.push(val - min);
+            if (val < min) min = val;
         }
     }
 
@@ -621,9 +685,7 @@ private:
     std::stack<long> stack;
 
 public:
-    MinStack() {
-        
-    }
+    MinStack() {}
     
     void push(int val) {
         if (stack.empty()) {
@@ -755,14 +817,14 @@ func Constructor() MinStack {
     }
 }
 
-func (this *MinStack) Push(x int) {
+func (this *MinStack) Push(val int) {
     if len(this.stack) == 0 {
         this.stack = append(this.stack, 0)
-        this.min = x
+        this.min = val
     } else {
-        this.stack = append(this.stack, x - this.min)
-        if x < this.min {
-            this.min = x
+        this.stack = append(this.stack, val - this.min)
+        if val < this.min {
+            this.min = val
         }
     }
 }
@@ -796,8 +858,8 @@ class MinStack() {
     private var min: Long = Long.MAX_VALUE
     private val stack = ArrayDeque<Long>()
 
-    fun push(x: Int) {
-        val valAsLong = x.toLong()
+    fun push(`val`: Int) {
+        val valAsLong = `val`.toLong()
         if (stack.isEmpty()) {
             stack.addLast(0L)
             min = valAsLong
@@ -828,6 +890,48 @@ class MinStack() {
 }
 ```
 
+```swift
+class MinStack {
+    private var minVal: Int = Int.max
+    private var stack: [Int] = []
+
+    init() {}
+
+    func push(_ val: Int) {
+        if stack.isEmpty {
+            stack.append(0)
+            minVal = val
+        } else {
+            stack.append(val - minVal)
+            if val < minVal {
+                minVal = val
+            }
+        }
+    }
+
+    func pop() {
+        if stack.isEmpty {
+            return
+        }
+        
+        let pop = stack.removeLast()
+        
+        if pop < 0 {
+            minVal -= pop
+        }
+    }
+
+    func top() -> Int {
+        let top = stack.last!
+        return top > 0 ? top + minVal : minVal
+    }
+
+    func getMin() -> Int {
+        return minVal
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/minimum-window-with-characters.md b/articles/minimum-window-with-characters.md
index 9e0b36005..887cb769c 100644
--- a/articles/minimum-window-with-characters.md
+++ b/articles/minimum-window-with-characters.md
@@ -279,6 +279,48 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minWindow(_ s: String, _ t: String) -> String {
+        if t.isEmpty {
+            return ""
+        }
+
+        var countT = [Character: Int]()
+        for c in t {
+            countT[c, default: 0] += 1
+        }
+
+        var res = [-1, -1]
+        var resLen = Int.max
+        let chars = Array(s)
+
+        for i in 0..<chars.count {
+            var countS = [Character: Int]()
+            for j in i..<chars.count {
+                countS[chars[j], default: 0] += 1
+
+                var flag = true
+                for (c, count) in countT {
+                    if count > countS[c, default: 0] {
+                        flag = false
+                        break
+                    }
+                }
+
+                if flag && (j - i + 1) < resLen {
+                    resLen = j - i + 1
+                    res = [i, j]
+                }
+            }
+        }
+
+        let (l, r) = (res[0], res[1])
+        return resLen != Int.max ? String(chars[l...r]) : ""
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -608,6 +650,53 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func minWindow(_ s: String, _ t: String) -> String {
+        if t.isEmpty {
+            return ""
+        }
+
+        var countT = [Character: Int]()
+        var window = [Character: Int]()
+        for c in t {
+            countT[c, default: 0] += 1
+        }
+
+        var have = 0, need = countT.count
+        var res = [-1, -1], resLen = Int.max
+        let chars = Array(s)
+        var l = 0
+
+        for r in 0..<chars.count {
+            let c = chars[r]
+            window[c, default: 0] += 1
+
+            if let count = countT[c], window[c] == count {
+                have += 1
+            }
+
+            while have == need {
+                if (r - l + 1) < resLen {
+                    res = [l, r]
+                    resLen = r - l + 1
+                }
+
+                let leftChar = chars[l]
+                window[leftChar, default: 0] -= 1
+                if let count = countT[leftChar], window[leftChar]! < count {
+                    have -= 1
+                }
+                l += 1
+            }
+        }
+
+        let (left, right) = (res[0], res[1])
+        return resLen != Int.max ? String(chars[left...right]) : ""
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/missing-number.md b/articles/missing-number.md
index 0ddb891db..24844c099 100644
--- a/articles/missing-number.md
+++ b/articles/missing-number.md
@@ -106,6 +106,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func missingNumber(_ nums: [Int]) -> Int {
+        var nums = nums.sorted()
+        let n = nums.count
+        for i in 0..<n {
+            if nums[i] != i {
+                return i
+            }
+        }
+        return n
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -227,6 +242,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func missingNumber(_ nums: [Int]) -> Int {
+        let numSet = Set(nums)
+        let n = nums.count
+        for i in 0...n {
+            if !numSet.contains(i) {
+                return i
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -331,6 +361,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func missingNumber(_ nums: [Int]) -> Int {
+        let n = nums.count
+        var xorr = n
+
+        for i in 0..<n {
+            xorr ^= i ^ nums[i]
+        }
+
+        return xorr
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -433,6 +478,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func missingNumber(_ nums: [Int]) -> Int {
+        var res = nums.count
+
+        for i in 0..<nums.count {
+            res += i - nums[i]
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/multiply-strings.md b/articles/multiply-strings.md
index e47825f08..eb53364f1 100644
--- a/articles/multiply-strings.md
+++ b/articles/multiply-strings.md
@@ -425,6 +425,72 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func multiply(_ num1: String, _ num2: String) -> String {
+        if num1 == "0" || num2 == "0" {
+            return "0"
+        }
+        if num1.count < num2.count {
+            return multiply(num2, num1)
+        }
+
+        var res = ""
+        var zero = 0
+        let num2Arr = Array(num2)
+
+        for i in stride(from: num2Arr.count - 1, through: 0, by: -1) {
+            let cur = mul(num1, num2Arr[i], zero)
+            res = add(res, cur)
+            zero += 1
+        }
+
+        return res
+    }
+
+    func mul(_ s: String, _ d: Character, _ zero: Int) -> String {
+        var i = s.count - 1
+        var carry = 0
+        let dInt = Int(String(d))!
+        let sArr = Array(s)
+        var cur = [String]()
+
+        while i >= 0 || carry > 0 {
+            let n = i >= 0 ? Int(String(sArr[i]))! : 0
+            let prod = n * dInt + carry
+            cur.append(String(prod % 10))
+            carry = prod / 10
+            i -= 1
+        }
+
+        let prodStr = cur.reversed().joined()
+        let zeros = String(repeating: "0", count: zero)
+        return prodStr + zeros
+    }
+
+    func add(_ num1: String, _ num2: String) -> String {
+        let s1 = Array(num1)
+        let s2 = Array(num2)
+        var i = s1.count - 1
+        var j = s2.count - 1
+        var carry = 0
+        var res = [String]()
+
+        while i >= 0 || j >= 0 || carry > 0 {
+            let n1 = i >= 0 ? Int(String(s1[i]))! : 0
+            let n2 = j >= 0 ? Int(String(s2[j]))! : 0
+            let total = n1 + n2 + carry
+            res.append(String(total % 10))
+            carry = total / 10
+            i -= 1
+            j -= 1
+        }
+
+        return res.reversed().joined()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -667,6 +733,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func multiply(_ num1: String, _ num2: String) -> String {
+        if num1 == "0" || num2 == "0" {
+            return "0"
+        }
+
+        let n1 = Array(num1.reversed()).map { Int(String($0))! }
+        let n2 = Array(num2.reversed()).map { Int(String($0))! }
+        var res = [Int](repeating: 0, count: num1.count + num2.count)
+
+        for i1 in 0..<n1.count {
+            for i2 in 0..<n2.count {
+                let digit = n1[i1] * n2[i2]
+                res[i1 + i2] += digit
+                res[i1 + i2 + 1] += res[i1 + i2] / 10
+                res[i1 + i2] %= 10
+            }
+        }
+
+        res.reverse()
+        var beg = 0
+        while beg < res.count && res[beg] == 0 {
+            beg += 1
+        }
+
+        return res[beg...].map { String($0) }.joined()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/n-queens.md b/articles/n-queens.md
index 523b992a6..e75cd714b 100644
--- a/articles/n-queens.md
+++ b/articles/n-queens.md
@@ -334,6 +334,57 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func solveNQueens(_ n: Int) -> [[String]] {
+        var res = [[String]]()
+        var board = Array(repeating: Array(repeating: ".", count: n), count: n)
+        
+        func backtrack(_ r: Int) {
+            if r == n {
+                let copy = board.map { $0.joined() }
+                res.append(copy)
+                return
+            }
+            for c in 0..<n {
+                if isSafe(r, c, board) {
+                    board[r][c] = "Q"
+                    backtrack(r + 1)
+                    board[r][c] = "."
+                }
+            }
+        }
+        
+        backtrack(0)
+        return res
+    }
+    
+    private func isSafe(_ r: Int, _ c: Int, _ board: [[String]]) -> Bool {
+        var row = r - 1
+        while row >= 0 {
+            if board[row][c] == "Q" { return false }
+            row -= 1
+        }
+        
+        var row1 = r - 1, col1 = c - 1
+        while row1 >= 0, col1 >= 0 {
+            if board[row1][col1] == "Q" { return false }
+            row1 -= 1
+            col1 -= 1
+        }
+        
+        var row2 = r - 1, col2 = c + 1
+        while row2 >= 0, col2 < board.count {
+            if board[row2][col2] == "Q" { return false }
+            row2 -= 1
+            col2 += 1
+        }
+        
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -666,6 +717,47 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func solveNQueens(_ n: Int) -> [[String]] {
+        var col = Set<Int>()
+        var posDiag = Set<Int>()
+        var negDiag = Set<Int>()
+        var res = [[String]]()
+        var board = Array(repeating: Array(repeating: ".", count: n), count: n)
+
+        func backtrack(_ r: Int) {
+            if r == n {
+                let copy = board.map { $0.joined() }
+                res.append(copy)
+                return
+            }
+
+            for c in 0..<n {
+                if col.contains(c) || posDiag.contains(r + c) || negDiag.contains(r - c) {
+                    continue
+                }
+
+                col.insert(c)
+                posDiag.insert(r + c)
+                negDiag.insert(r - c)
+                board[r][c] = "Q"
+
+                backtrack(r + 1)
+
+                col.remove(c)
+                posDiag.remove(r + c)
+                negDiag.remove(r - c)
+                board[r][c] = "."
+            }
+        }
+
+        backtrack(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -986,6 +1078,47 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func solveNQueens(_ n: Int) -> [[String]] {
+        var col = Array(repeating: false, count: n)
+        var posDiag = Array(repeating: false, count: 2 * n)
+        var negDiag = Array(repeating: false, count: 2 * n)
+        var res = [[String]]()
+        var board = Array(repeating: Array(repeating: ".", count: n), count: n)
+
+        func backtrack(_ r: Int) {
+            if r == n {
+                let copy = board.map { $0.joined() }
+                res.append(copy)
+                return
+            }
+            
+            for c in 0..<n {
+                if col[c] || posDiag[r + c] || negDiag[r - c + n] {
+                    continue
+                }
+                
+                col[c] = true
+                posDiag[r + c] = true
+                negDiag[r - c + n] = true
+                board[r][c] = "Q"
+
+                backtrack(r + 1)
+
+                col[c] = false
+                posDiag[r + c] = false
+                negDiag[r - c + n] = false
+                board[r][c] = "."
+            }
+        }
+
+        backtrack(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1296,6 +1429,48 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func solveNQueens(_ n: Int) -> [[String]] {
+        var col = 0
+        var posDiag = 0
+        var negDiag = 0
+        var res = [[String]]()
+        var board = Array(repeating: Array(repeating: ".", count: n), count: n)
+
+        func backtrack(_ r: Int) {
+            if r == n {
+                let copy = board.map { $0.joined() }
+                res.append(copy)
+                return
+            }
+            
+            for c in 0..<n {
+                if ((col & (1 << c)) != 0 || (posDiag & (1 << (r + c))) != 0 ||
+                    (negDiag & (1 << (r - c + n))) != 0) {
+                    continue
+                }
+                
+                col ^= (1 << c)
+                posDiag ^= (1 << (r + c))
+                negDiag ^= (1 << (r - c + n))
+                board[r][c] = "Q"
+
+                backtrack(r + 1)
+
+                col ^= (1 << c)
+                posDiag ^= (1 << (r + c))
+                negDiag ^= (1 << (r - c + n))
+                board[r][c] = "."
+            }
+        }
+
+        backtrack(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/network-delay-time.md b/articles/network-delay-time.md
index 1a9aa0afb..ae9fb93fc 100644
--- a/articles/network-delay-time.md
+++ b/articles/network-delay-time.md
@@ -216,6 +216,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func networkDelayTime(_ times: [[Int]], _ n: Int, _ k: Int) -> Int {
+        var adj = [Int: [(Int, Int)]]()
+        for time in times {
+            let u = time[0], v = time[1], w = time[2]
+            adj[u, default: []].append((v, w))
+        }
+
+        var dist = [Int: Int]()
+        for node in 1...n {
+            dist[node] = Int.max
+        }
+
+        func dfs(_ node: Int, _ time: Int) {
+            if time >= dist[node]! {
+                return
+            }
+            
+            dist[node] = time
+            if let neighbors = adj[node] {
+                for (nei, w) in neighbors {
+                    dfs(nei, time + w)
+                }
+            }
+        }
+
+        dfs(k, 0)
+        let res = dist.values.max()!
+        return res == Int.max ? -1 : res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -450,6 +484,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func networkDelayTime(_ times: [[Int]], _ n: Int, _ k: Int) -> Int {
+        let inf = Int.max / 2
+        var dist = Array(repeating: Array(repeating: inf, count: n), count: n)
+        
+        for time in times {
+            let u = time[0] - 1, v = time[1] - 1, w = time[2]
+            dist[u][v] = w
+        }
+        for i in 0..<n {
+            dist[i][i] = 0
+        }
+
+        for mid in 0..<n {
+            for i in 0..<n {
+                for j in 0..<n {
+                    dist[i][j] = min(dist[i][j], dist[i][mid] + dist[mid][j])
+                }
+            }
+        }
+
+        let res = dist[k - 1].max()!
+        return res >= inf ? -1 : res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -621,6 +683,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func networkDelayTime(_ times: [[Int]], _ n: Int, _ k: Int) -> Int {
+        var dist = Array(repeating: Int.max, count: n)
+        dist[k - 1] = 0
+
+        for _ in 0..<n - 1 {
+            var updated = false
+            for time in times {
+                let u = time[0] - 1, v = time[1] - 1, w = time[2]
+                if dist[u] != Int.max && dist[u] + w < dist[v] {
+                    dist[v] = dist[u] + w
+                    updated = true
+                }
+            }
+            if !updated {
+                break
+            }
+        }
+
+        let maxDist = dist.max()!
+        return maxDist == Int.max ? -1 : maxDist
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -886,6 +974,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func networkDelayTime(_ times: [[Int]], _ n: Int, _ k: Int) -> Int {
+        var adj = [Int: [(Int, Int)]]()
+        for time in times {
+            let u = time[0], v = time[1], w = time[2]
+            adj[u, default: []].append((v, w))
+        }
+
+        var dist = [Int: Int]()
+        for node in 1...n {
+            dist[node] = Int.max
+        }
+        dist[k] = 0
+
+        var queue = Deque<(Int, Int)>()
+        queue.append((k, 0))
+
+        while !queue.isEmpty {
+            let (node, time) = queue.popFirst()!
+            if dist[node]! < time {
+                continue
+            }
+            if let neighbors = adj[node] {
+                for (nei, w) in neighbors {
+                    if time + w < dist[nei]! {
+                        dist[nei] = time + w
+                        queue.append((nei, time + w))
+                    }
+                }
+            }
+        }
+
+        let res = dist.values.max()!
+        return res == Int.max ? -1 : res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1175,6 +1302,53 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let weight: Int
+    let node: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.weight < rhs.weight
+    }
+}
+
+class Solution {
+    func networkDelayTime(_ times: [[Int]], _ n: Int, _ k: Int) -> Int {
+        var edges = [Int: [(Int, Int)]]()
+        for time in times {
+            let u = time[0], v = time[1], w = time[2]
+            edges[u, default: []].append((v, w))
+        }
+
+        var minHeap = Heap<Item>()
+        minHeap.insert(Item(weight: 0, node: k))
+        var visit = Set<Int>()
+        var t = 0
+
+        while !minHeap.isEmpty {
+            let item = minHeap.removeMin()
+            let w1 = item.weight
+            let n1 = item.node
+
+            if visit.contains(n1) {
+                continue
+            }
+            visit.insert(n1)
+            t = w1
+
+            if let neighbors = edges[n1] {
+                for (n2, w2) in neighbors {
+                    if !visit.contains(n2) {
+                        minHeap.insert(Item(weight: w1 + w2, node: n2))
+                    }
+                }
+            }
+        }
+        return visit.count == n ? t : -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/non-cyclical-number.md b/articles/non-cyclical-number.md
index 5290a69a7..6b3053011 100644
--- a/articles/non-cyclical-number.md
+++ b/articles/non-cyclical-number.md
@@ -206,6 +206,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isHappy(_ n: Int) -> Bool {
+        var visit = Set<Int>()
+        var num = n
+
+        while !visit.contains(num) {
+            visit.insert(num)
+            num = sumOfSquares(num)
+            if num == 1 {
+                return true
+            }
+        }
+        return false
+    }
+
+    private func sumOfSquares(_ n: Int) -> Int {
+        var num = n
+        var output = 0
+
+        while num > 0 {
+            let digit = num % 10
+            output += digit * digit
+            num /= 10
+        }
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -404,6 +434,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isHappy(_ n: Int) -> Bool {
+        var slow = n
+        var fast = sumOfSquares(n)
+
+        while slow != fast {
+            fast = sumOfSquares(fast)
+            fast = sumOfSquares(fast)
+            slow = sumOfSquares(slow)
+        }
+        return fast == 1
+    }
+
+    private func sumOfSquares(_ n: Int) -> Int {
+        var num = n
+        var output = 0
+
+        while num > 0 {
+            let digit = num % 10
+            output += digit * digit
+            num /= 10
+        }
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -636,6 +694,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isHappy(_ n: Int) -> Bool {
+        var slow = n
+        var fast = sumOfSquares(n)
+        var power = 1
+        var lam = 1
+
+        while slow != fast {
+            if power == lam {
+                slow = fast
+                power *= 2
+                lam = 0
+            }
+            fast = sumOfSquares(fast)
+            lam += 1
+        }
+        return fast == 1
+    }
+
+    private func sumOfSquares(_ n: Int) -> Int {
+        var num = n
+        var output = 0
+
+        while num > 0 {
+            let digit = num % 10
+            output += digit * digit
+            num /= 10
+        }
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/non-overlapping-intervals.md b/articles/non-overlapping-intervals.md
index 7970155cb..60f0b89a1 100644
--- a/articles/non-overlapping-intervals.md
+++ b/articles/non-overlapping-intervals.md
@@ -147,6 +147,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func eraseOverlapIntervals(_ intervals: [[Int]]) -> Int {
+        var intervals = intervals
+        intervals.sort { $0[0] < $1[0] }
+
+        func dfs(_ i: Int, _ prev: Int) -> Int {
+            if i == intervals.count {
+                return 0
+            }
+            var res = dfs(i + 1, prev)
+            if prev == -1 || intervals[prev][1] <= intervals[i][0] {
+                res = max(res, 1 + dfs(i + 1, i))
+            }
+            return res
+        }
+
+        return intervals.count - dfs(0, -1)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -365,6 +387,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func eraseOverlapIntervals(_ intervals: [[Int]]) -> Int {
+        var intervals = intervals
+        intervals.sort { $0[1] < $1[1] }
+        let n = intervals.count
+        var memo = [Int: Int]()
+
+        func dfs(_ i: Int) -> Int {
+            if let result = memo[i] {
+                return result
+            }
+
+            var res = 1
+            for j in i + 1..<n {
+                if intervals[i][1] <= intervals[j][0] {
+                    res = max(res, 1 + dfs(j))
+                }
+            }
+            memo[i] = res
+            return res
+        }
+
+        return n - dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -549,6 +599,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func eraseOverlapIntervals(_ intervals: [[Int]]) -> Int {
+        var intervals = intervals
+        intervals.sort { $0[1] < $1[1] }
+        let n = intervals.count
+        var dp = [Int](repeating: 0, count: n)
+
+        for i in 0..<n {
+            dp[i] = 1
+            for j in 0..<i {
+                if intervals[j][1] <= intervals[i][0] {
+                    dp[i] = max(dp[i], 1 + dp[j])
+                }
+            }
+        }
+
+        let maxNonOverlapping = dp.max() ?? 0
+        return n - maxNonOverlapping
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -808,6 +881,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func eraseOverlapIntervals(_ intervals: [[Int]]) -> Int {
+        var intervals = intervals
+        intervals.sort { $0[1] < $1[1] }
+        let n = intervals.count
+        var dp = [Int](repeating: 0, count: n)
+        dp[0] = 1
+
+        func bs(_ r: Int, _ target: Int) -> Int {
+            var l = 0
+            var r = r
+            while l < r {
+                let m = (l + r) >> 1
+                if intervals[m][1] <= target {
+                    l = m + 1
+                } else {
+                    r = m
+                }
+            }
+            return l
+        }
+
+        for i in 1..<n {
+            let idx = bs(i, intervals[i][0])
+            if idx == 0 {
+                dp[i] = dp[i - 1]
+            } else {
+                dp[i] = max(dp[i - 1], 1 + dp[idx - 1])
+            }
+        }
+        return n - dp[n - 1]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -981,6 +1090,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func eraseOverlapIntervals(_ intervals: [[Int]]) -> Int {
+        var intervals = intervals
+        intervals.sort { $0[0] < $1[0] }
+        
+        var res = 0
+        var prevEnd = intervals[0][1]
+        
+        for i in 1..<intervals.count {
+            let start = intervals[i][0]
+            let end = intervals[i][1]
+            if start >= prevEnd {
+                prevEnd = end
+            } else {
+                res += 1
+                prevEnd = min(end, prevEnd)
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1142,6 +1275,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func eraseOverlapIntervals(_ intervals: [[Int]]) -> Int {
+        var intervals = intervals
+        intervals.sort { $0[1] < $1[1] }
+        
+        var prevEnd = intervals[0][1]
+        var res = 0
+        
+        for i in 1..<intervals.count {
+            if prevEnd > intervals[i][0] {
+                res += 1
+            } else {
+                prevEnd = intervals[i][1]
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/number-of-one-bits.md b/articles/number-of-one-bits.md
index 9468bf89b..4ea545b0d 100644
--- a/articles/number-of-one-bits.md
+++ b/articles/number-of-one-bits.md
@@ -99,6 +99,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hammingWeight(_ n: Int) -> Int {
+        var res = 0
+        for i in 0..<32 {
+            if (1 << i) & n != 0 {
+                res += 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -208,6 +222,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hammingWeight(_ n: Int) -> Int {
+        var n = n
+        var res = 0
+        while n != 0 {
+            res += (n & 1) != 0 ? 1 : 0
+            n >>= 1
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -313,6 +341,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hammingWeight(_ n: Int) -> Int {
+        var n = n
+        var res = 0
+        while n != 0 {
+            n &= (n - 1)
+            res += 1
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -383,6 +425,14 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func hammingWeight(_ n: Int) -> Int {
+        return n.nonzeroBitCount
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/pacific-atlantic-water-flow.md b/articles/pacific-atlantic-water-flow.md
index 1b718571a..1245a570d 100644
--- a/articles/pacific-atlantic-water-flow.md
+++ b/articles/pacific-atlantic-water-flow.md
@@ -351,6 +351,57 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func pacificAtlantic(_ heights: [[Int]]) -> [[Int]] {
+        var heights = heights
+        let ROWS = heights.count
+        let COLS = heights[0].count
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+
+        var pacific = false
+        var atlantic = false
+
+        func dfs(_ r: Int, _ c: Int, _ prevVal: Int) {
+            if r < 0 || c < 0 {
+                pacific = true
+                return
+            }
+            if r >= ROWS || c >= COLS {
+                atlantic = true
+                return
+            }
+            if heights[r][c] > prevVal {
+                return
+            }
+
+            let tmp = heights[r][c]
+            heights[r][c] = Int.max
+            for dir in directions {
+                dfs(r + dir.0, c + dir.1, tmp)
+                if pacific && atlantic {
+                    break
+                }
+            }
+            heights[r][c] = tmp
+        }
+
+        var res = [[Int]]()
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                pacific = false
+                atlantic = false
+                dfs(r, c, Int.max)
+                if pacific && atlantic {
+                    res.append([r, c])
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -677,6 +728,49 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func pacificAtlantic(_ heights: [[Int]]) -> [[Int]] {
+        let ROWS = heights.count
+        let COLS = heights[0].count
+        var pac = Set<[Int]>()
+        var atl = Set<[Int]>()
+
+        func dfs(_ r: Int, _ c: Int, _ visit: inout Set<[Int]>, _ prevHeight: Int) {
+            if (visit.contains([r, c]) || r < 0 || c < 0 || r == ROWS ||
+                c == COLS || heights[r][c] < prevHeight) {
+                return
+            }
+            visit.insert([r, c])
+            dfs(r + 1, c, &visit, heights[r][c])
+            dfs(r - 1, c, &visit, heights[r][c])
+            dfs(r, c + 1, &visit, heights[r][c])
+            dfs(r, c - 1, &visit, heights[r][c])
+        }
+
+        for c in 0..<COLS {
+            dfs(0, c, &pac, heights[0][c])
+            dfs(ROWS - 1, c, &atl, heights[ROWS - 1][c])
+        }
+
+        for r in 0..<ROWS {
+            dfs(r, 0, &pac, heights[r][0])
+            dfs(r, COLS - 1, &atl, heights[r][COLS - 1])
+        }
+
+        var res = [[Int]]()
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if pac.contains([r, c]) && atl.contains([r, c]) {
+                    res.append([r, c])
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1065,6 +1159,61 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func pacificAtlantic(_ heights: [[Int]]) -> [[Int]] {
+        let ROWS = heights.count
+        let COLS = heights[0].count
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+
+        var pac = Array(repeating: Array(repeating: false, count: COLS), count: ROWS)
+        var atl = Array(repeating: Array(repeating: false, count: COLS), count: ROWS)
+
+        func bfs(_ source: [(Int, Int)], _ ocean: inout [[Bool]]) {
+            var queue = Deque(source)
+            while !queue.isEmpty {
+                let (r, c) = queue.popFirst()!
+                ocean[r][c] = true
+                for dir in directions {
+                    let nr = r + dir.0
+                    let nc = c + dir.1
+                    if nr >= 0, nr < ROWS, nc >= 0, nc < COLS, 
+                       !ocean[nr][nc], heights[nr][nc] >= heights[r][c] {
+                        queue.append((nr, nc))
+                    }
+                }
+            }
+        }
+
+        var pacific: [(Int, Int)] = []
+        var atlantic: [(Int, Int)] = []
+
+        for c in 0..<COLS {
+            pacific.append((0, c))
+            atlantic.append((ROWS - 1, c))
+        }
+
+        for r in 0..<ROWS {
+            pacific.append((r, 0))
+            atlantic.append((r, COLS - 1))
+        }
+
+        bfs(pacific, &pac)
+        bfs(atlantic, &atl)
+
+        var res = [[Int]]()
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if pac[r][c] && atl[r][c] {
+                    res.append([r, c])
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/palindrome-partitioning.md b/articles/palindrome-partitioning.md
index 4b954a755..3e87916a5 100644
--- a/articles/palindrome-partitioning.md
+++ b/articles/palindrome-partitioning.md
@@ -1,4 +1,4 @@
-## 1. Backtracking (Pick / Not Pick)
+## 1. Backtracking - I
 
 ::tabs-start
 
@@ -282,16 +282,60 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func partition(_ s: String) -> [[String]] {
+        var res = [[String]]()
+        var part = [String]()
+        let sArray = Array(s)
+
+        func dfs(_ j: Int, _ i: Int) {
+            if i >= sArray.count {
+                if i == j {
+                    res.append(part)
+                }
+                return
+            }
+
+            if isPali(sArray, j, i) {
+                part.append(String(sArray[j...i]))
+                dfs(i + 1, i + 1)
+                part.removeLast()
+            }
+
+            dfs(j, i + 1)
+        }
+
+        func isPali(_ s: [Character], _ l: Int, _ r: Int) -> Bool {
+            var l = l, r = r
+            while l < r {
+                if s[l] != s[r] {
+                    return false
+                }
+                l += 1
+                r -= 1
+            }
+            return true
+        }
+
+        dfs(0, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(n * 2 ^ n)$ space for the output list.
 
 ---
 
-## 2. Backtracking
+## 2. Backtracking - II
 
 ::tabs-start
 
@@ -562,12 +606,53 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func partition(_ s: String) -> [[String]] {
+        var res = [[String]]()
+        var part = [String]()
+        let sArray = Array(s)
+
+        func dfs(_ i: Int) {
+            if i >= sArray.count {
+                res.append(part)
+                return
+            }
+            for j in i..<sArray.count {
+                if isPali(sArray, i, j) {
+                    part.append(String(sArray[i...j]))
+                    dfs(j + 1)
+                    part.removeLast()
+                }
+            }
+        }
+
+        func isPali(_ s: [Character], _ l: Int, _ r: Int) -> Bool {
+            var l = l, r = r
+            while l < r {
+                if s[l] != s[r] {
+                    return false
+                }
+                l += 1
+                r -= 1
+            }
+            return true
+        }
+
+        dfs(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(n * 2 ^ n)$ space for the output list.
 
 ---
 
@@ -823,12 +908,51 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func partition(_ s: String) -> [[String]] {
+        let n = s.count
+        let sArray = Array(s)
+        var dp = Array(repeating: Array(repeating: false, count: n), count: n)
+        
+        for l in 1...n {
+            for i in 0...(n - l) {
+                dp[i][i + l - 1] = (sArray[i] == sArray[i + l - 1] &&
+                                    (i + 1 > (i + l - 2) || dp[i + 1][i + l - 2]))
+            }
+        }
+
+        var res = [[String]]()
+        var part = [String]()
+
+        func dfs(_ i: Int) {
+            if i >= sArray.count {
+                res.append(part)
+                return
+            }
+            for j in i..<sArray.count {
+                if dp[i][j] {
+                    part.append(String(sArray[i...j]))
+                    dfs(j + 1)
+                    part.removeLast()
+                }
+            }
+        }
+
+        dfs(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n ^ 2)$
+* Space complexity:
+    * $O(n ^ 2)$ extra space.
+    * $O(n * 2 ^ n)$ space for the output list.
 
 ---
 
@@ -1094,9 +1218,50 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func partition(_ s: String) -> [[String]] {
+        let n = s.count
+        let sArray = Array(s)
+        var dp = Array(repeating: Array(repeating: false, count: n), count: n)
+
+        for l in 1...n {
+            for i in 0...(n - l) {
+                dp[i][i + l - 1] = (sArray[i] == sArray[i + l - 1] &&
+                                    (i + 1 > (i + l - 2) || dp[i + 1][i + l - 2]))
+            }
+        }
+
+        func dfs(_ i: Int) -> [[String]] {
+            if i >= n {
+                return [[]]
+            }
+
+            var ret = [[String]]()
+            for j in i..<n {
+                if dp[i][j] {
+                    let nextPartitions = dfs(j + 1)
+                    for part in nextPartitions {
+                        var cur = [String]()
+                        cur.append(String(sArray[i...j]))
+                        cur.append(contentsOf: part)
+                        ret.append(cur)
+                    }
+                }
+            }
+            return ret
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n ^ 2)$
\ No newline at end of file
+* Space complexity:
+    * $O(n ^ 2)$ extra space.
+    * $O(n * 2 ^ n)$ space for the output list.
\ No newline at end of file
diff --git a/articles/palindromic-substrings.md b/articles/palindromic-substrings.md
index ad44822d6..cd1dfa352 100644
--- a/articles/palindromic-substrings.md
+++ b/articles/palindromic-substrings.md
@@ -148,6 +148,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countSubstrings(_ s: String) -> Int {
+        let chars = Array(s)
+        var res = 0
+
+        for i in 0..<chars.count {
+            for j in i..<chars.count {
+                var l = i, r = j
+                while l < r && chars[l] == chars[r] {
+                    l += 1
+                    r -= 1
+                }
+                if l >= r {
+                    res += 1
+                }
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -313,6 +337,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countSubstrings(_ s: String) -> Int {
+        let n = s.count
+        var res = 0
+        var dp = Array(repeating: Array(repeating: false, count: n), count: n)
+        let chars = Array(s)
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            for j in i..<n {
+                if chars[i] == chars[j] && (j - i <= 2 || dp[i + 1][j - 1]) {
+                    dp[i][j] = true
+                    res += 1
+                }
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -535,6 +581,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countSubstrings(_ s: String) -> Int {
+        let chars = Array(s)
+        var res = 0
+        
+        for i in 0..<chars.count {
+            // Odd length palindromes
+            var l = i, r = i
+            while l >= 0 && r < chars.count && chars[l] == chars[r] {
+                res += 1
+                l -= 1
+                r += 1
+            }
+
+            // Even length palindromes
+            l = i
+            r = i + 1
+            while l >= 0 && r < chars.count && chars[l] == chars[r] {
+                res += 1
+                l -= 1
+                r += 1
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -722,6 +798,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countSubstrings(_ s: String) -> Int {
+        var res = 0
+        let chars = Array(s)
+
+        for i in 0..<chars.count {
+            res += countPali(chars, i, i)
+            res += countPali(chars, i, i + 1)
+        }
+        return res
+    }
+
+    private func countPali(_ s: [Character], _ l: Int, _ r: Int) -> Int {
+        var res = 0
+        var left = l, right = r
+
+        while left >= 0 && right < s.count && s[left] == s[right] {
+            res += 1
+            left -= 1
+            right += 1
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -982,6 +1085,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func countSubstrings(_ s: String) -> Int {
+        func manacher(_ s: String) -> [Int] {
+            let t = "#" + s.map { "\($0)#" }.joined()
+            let chars = Array(t)
+            let n = chars.count
+            var p = Array(repeating: 0, count: n)
+            var l = 0, r = 0
+
+            for i in 0..<n {
+                if i < r {
+                    p[i] = min(r - i, p[l + (r - i)])
+                }
+                while i + p[i] + 1 < n, i - p[i] - 1 >= 0,
+                      chars[i + p[i] + 1] == chars[i - p[i] - 1] {
+                    p[i] += 1
+                }
+                if i + p[i] > r {
+                    l = i - p[i]
+                    r = i + p[i]
+                }
+            }
+            return p
+        }
+
+        let p = manacher(s)
+        var res = 0
+        for i in p {
+            res += (i + 1) / 2
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/partition-equal-subset-sum.md b/articles/partition-equal-subset-sum.md
index d51654692..6d6fd0caa 100644
--- a/articles/partition-equal-subset-sum.md
+++ b/articles/partition-equal-subset-sum.md
@@ -194,6 +194,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canPartition(_ nums: [Int]) -> Bool {
+        let totalSum = nums.reduce(0, +)
+        if totalSum % 2 != 0 {
+            return false
+        }
+
+        let target = totalSum / 2
+        let n = nums.count
+
+        func dfs(_ i: Int, _ target: Int) -> Bool {
+            if i >= n {
+                return target == 0
+            }
+            if target < 0 {
+                return false
+            }
+
+            return dfs(i + 1, target) || dfs(i + 1, target - nums[i])
+        }
+
+        return dfs(0, target)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -454,6 +481,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canPartition(_ nums: [Int]) -> Bool {
+        let total = nums.reduce(0, +)
+        if total % 2 != 0 {
+            return false
+        }
+
+        let target = total / 2
+        let n = nums.count
+        var memo = Array(repeating: Array(repeating: -1, count: target + 1), count: n + 1)
+
+        func dfs(_ i: Int, _ target: Int) -> Bool {
+            if target == 0 {
+                return true
+            }
+            if i >= n || target < 0 {
+                return false
+            }
+            if memo[i][target] != -1 {
+                return memo[i][target] == 1
+            }
+
+            let result = dfs(i + 1, target) || dfs(i + 1, target - nums[i])
+            memo[i][target] = result ? 1 : 0
+            return result
+        }
+
+        return dfs(0, target)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -702,6 +762,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canPartition(_ nums: [Int]) -> Bool {
+        let total = nums.reduce(0, +)
+        if total % 2 != 0 {
+            return false
+        }
+
+        let target = total / 2
+        let n = nums.count
+        var dp = Array(repeating: Array(repeating: false, count: target + 1), count: n + 1)
+
+        for i in 0...n {
+            dp[i][0] = true
+        }
+
+        for i in 1...n {
+            for j in 1...target {
+                if nums[i - 1] <= j {
+                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i - 1]]
+                } else {
+                    dp[i][j] = dp[i - 1][j]
+                }
+            }
+        }
+
+        return dp[n][target]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -940,6 +1031,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canPartition(_ nums: [Int]) -> Bool {
+        if nums.reduce(0, +) % 2 != 0 {
+            return false
+        }
+
+        let target = nums.reduce(0, +) / 2
+        var dp = Array(repeating: false, count: target + 1)
+        var nextDp = Array(repeating: false, count: target + 1)
+
+        dp[0] = true
+        for num in nums {
+            for j in stride(from: target, through: 1, by: -1) {
+                if j >= num {
+                    nextDp[j] = dp[j] || dp[j - num]
+                } else {
+                    nextDp[j] = dp[j]
+                }
+            }
+            swap(&dp, &nextDp)
+        }
+
+        return dp[target]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1147,6 +1266,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canPartition(_ nums: [Int]) -> Bool {
+        if nums.reduce(0, +) % 2 != 0 {
+            return false
+        }
+
+        var dp: Set<Int> = [0]
+        let target = nums.reduce(0, +) / 2
+
+        for i in stride(from: nums.count - 1, through: 0, by: -1) {
+            var nextDP: Set<Int> = []
+            for t in dp {
+                if t + nums[i] == target {
+                    return true
+                }
+                nextDP.insert(t + nums[i])
+                nextDP.insert(t)
+            }
+            dp = nextDP
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1342,6 +1487,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func canPartition(_ nums: [Int]) -> Bool {
+        if nums.reduce(0, +) % 2 != 0 {
+            return false
+        }
+
+        let target = nums.reduce(0, +) / 2
+        var dp = Array(repeating: false, count: target + 1)
+
+        dp[0] = true
+        for num in nums {
+            for j in stride(from: target, through: num, by: -1) {
+                dp[j] = dp[j] || dp[j - num]
+            }
+        }
+
+        return dp[target]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1366,10 +1533,10 @@ class Solution:
 
         target = total // 2
         dp = 1 << 0
-        
+
         for num in nums:
             dp |= dp << num
-            
+
         return (dp & (1 << target)) != 0
 ```
 
diff --git a/articles/partition-labels.md b/articles/partition-labels.md
index 5eb089e85..1e4e2b3a1 100644
--- a/articles/partition-labels.md
+++ b/articles/partition-labels.md
@@ -169,6 +169,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func partitionLabels(_ s: String) -> [Int] {
+        var lastIndex = [Character: Int]()
+        for (i, c) in s.enumerated() {
+            lastIndex[c] = i
+        }
+
+        var res = [Int]()
+        var size = 0
+        var end = 0
+        for (i, c) in s.enumerated() {
+            size += 1
+            end = max(end, lastIndex[c]!)
+
+            if i == end {
+                res.append(size)
+                size = 0
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/permutation-string.md b/articles/permutation-string.md
index 07e79c7ef..482890ee4 100644
--- a/articles/permutation-string.md
+++ b/articles/permutation-string.md
@@ -149,6 +149,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
+        let s1Sorted = s1.sorted()
+        let chars = Array(s2)
+
+        for i in 0..<chars.count {
+            for j in i..<chars.count {
+                let subStr = String(chars[i...j]).sorted()
+                if subStr == s1Sorted {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -391,12 +410,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
+        var count1 = [Character: Int]()
+        for c in s1 {
+            count1[c, default: 0] += 1
+        }
+        
+        let need = count1.count
+        let chars = Array(s2)
+
+        for i in 0..<chars.count {
+            var count2 = [Character: Int]()
+            var cur = 0
+
+            for j in i..<chars.count {
+                count2[chars[j], default: 0] += 1
+                if count1[chars[j], default: 0] < count2[chars[j], default: 0] {
+                    break
+                }
+                if count1[chars[j], default: 0] == count2[chars[j], default: 0] {
+                    cur += 1
+                }
+                if cur == need {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * m)$
-* Space complexity: $O(1)$
+* Space complexity: $O(1)$ since we have at most $26$ different characters.
 
 > Where $n$ is the length of the string1 and $m$ is the length of string2.
 
@@ -736,6 +788,61 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
+        if s1.count > s2.count {
+            return false
+        }
+
+        var s1Count = [Int](repeating: 0, count: 26)
+        var s2Count = [Int](repeating: 0, count: 26)
+        let aAscii = Int(Character("a").asciiValue!)
+
+        let s1Array = Array(s1)
+        let s2Array = Array(s2)
+
+        for i in 0..<s1.count {
+            s1Count[Int(s1Array[i].asciiValue!) - aAscii] += 1
+            s2Count[Int(s2Array[i].asciiValue!) - aAscii] += 1
+        }
+
+        var matches = 0
+        for i in 0..<26 {
+            if s1Count[i] == s2Count[i] {
+                matches += 1
+            }
+        }
+
+        var l = 0
+        for r in s1.count..<s2.count {
+            if matches == 26 {
+                return true
+            }
+
+            var index = Int(s2Array[r].asciiValue!) - aAscii
+            s2Count[index] += 1
+            if s1Count[index] == s2Count[index] {
+                matches += 1
+            } else if s1Count[index] + 1 == s2Count[index] {
+                matches -= 1
+            }
+
+            index = Int(s2Array[l].asciiValue!) - aAscii
+            s2Count[index] -= 1
+            if s1Count[index] == s2Count[index] {
+                matches += 1
+            } else if s1Count[index] - 1 == s2Count[index] {
+                matches -= 1
+            }
+            l += 1
+        }
+
+        return matches == 26
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/permutations.md b/articles/permutations.md
index 492290c73..83dea1986 100644
--- a/articles/permutations.md
+++ b/articles/permutations.md
@@ -146,6 +146,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func permute(_ nums: [Int]) -> [[Int]] {
+        if nums.isEmpty {
+            return [[]]
+        }
+
+        let perms = permute(Array(nums.dropFirst()))
+        var res = [[Int]]()
+
+        for p in perms {
+            for i in 0...p.count {
+                var pCopy = p
+                pCopy.insert(nums[0], at: i)
+                res.append(pCopy)
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -303,6 +326,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func permute(_ nums: [Int]) -> [[Int]] {
+        var perms: [[Int]] = [[]]
+
+        for num in nums {
+            var newPerms = [[Int]]()
+            for p in perms {
+                for i in 0...p.count {
+                    var pCopy = p
+                    pCopy.insert(num, at: i)
+                    newPerms.append(pCopy)
+                }
+            }
+            perms = newPerms
+        }
+
+        return perms
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -501,6 +546,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func permute(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var pick = [Bool](repeating: false, count: nums.count)
+
+        func backtrack(_ perm: inout [Int]) {
+            if perm.count == nums.count {
+                res.append(perm)
+                return
+            }
+            for i in 0..<nums.count {
+                if !pick[i] {
+                    perm.append(nums[i])
+                    pick[i] = true
+                    backtrack(&perm)
+                    perm.popLast()
+                    pick[i] = false
+                }
+            }
+        }
+
+        var perm = [Int]()
+        backtrack(&perm)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -691,6 +765,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func permute(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+
+        func backtrack(_ perm: inout [Int], _ mask: Int) {
+            if perm.count == nums.count {
+                res.append(perm)
+                return
+            }
+            for i in 0..<nums.count {
+                if mask & (1 << i) == 0 {
+                    perm.append(nums[i])
+                    backtrack(&perm, mask | (1 << i))
+                    perm.popLast()
+                }
+            }
+        }
+
+        var perm = [Int]()
+        backtrack(&perm, 0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -889,6 +989,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func permute(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var nums = nums
+
+        func backtrack(_ idx: Int) {
+            if idx == nums.count {
+                res.append(nums)
+                return
+            }
+            for i in idx..<nums.count {
+                nums.swapAt(idx, i)
+                backtrack(idx + 1)
+                nums.swapAt(idx, i)
+            }
+        }
+
+        backtrack(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/plus-one.md b/articles/plus-one.md
index 4b51b5b0c..a5b43fb09 100644
--- a/articles/plus-one.md
+++ b/articles/plus-one.md
@@ -130,6 +130,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func plusOne(_ digits: [Int]) -> [Int] {
+        if digits.isEmpty {
+            return [1]
+        }
+
+        var digits = digits
+        if digits[digits.count - 1] < 9 {
+            digits[digits.count - 1] += 1
+            return digits
+        } else {
+            return plusOne(Array(digits.dropLast())) + [0]
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -341,6 +359,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func plusOne(_ digits: [Int]) -> [Int] {
+        var digits = digits
+        var one = 1
+        var i = 0
+        digits.reverse()
+
+        while one > 0 {
+            if i < digits.count {
+                if digits[i] == 9 {
+                    digits[i] = 0
+                } else {
+                    digits[i] += 1
+                    one = 0
+                }
+            } else {
+                digits.append(one)
+                one = 0
+            }
+            i += 1
+        }
+
+        digits.reverse()
+        return digits
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -476,6 +523,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func plusOne(_ digits: [Int]) -> [Int] {
+        var digits = digits
+        let n = digits.count
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            if digits[i] < 9 {
+                digits[i] += 1
+                return digits
+            }
+            digits[i] = 0
+        }
+
+        return [1] + digits
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/pow-x-n.md b/articles/pow-x-n.md
index 341e3ae9d..50beeb0f4 100644
--- a/articles/pow-x-n.md
+++ b/articles/pow-x-n.md
@@ -139,6 +139,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func myPow(_ x: Double, _ n: Int) -> Double {
+        if x == 0 {
+            return 0
+        }
+        if n == 0 {
+            return 1
+        }
+
+        var res: Double = 1
+        for _ in 0..<abs(n) {
+            res *= x
+        }
+        return n >= 0 ? res : 1 / res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -320,12 +339,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func myPow(_ x: Double, _ n: Int) -> Double {
+        func helper(_ x: Double, _ n: Int) -> Double {
+            if x == 0 {
+                return 0
+            }
+            if n == 0 {
+                return 1
+            }
+
+            let res = helper(x * x, n / 2)
+            return n % 2 == 0 ? res : x * res
+        }
+
+        let res = helper(x, abs(n))
+        return n >= 0 ? res : 1 / res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(\log n)$
-* Space complexity: $O(\log n)$
+* Space complexity: $O(\log n)$ for recursion stack.
 
 ---
 
@@ -501,6 +541,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func myPow(_ x: Double, _ n: Int) -> Double {
+        if x == 0 {
+            return 0
+        }
+        if n == 0 {
+            return 1
+        }
+
+        var res: Double = 1
+        var base = x
+        var power = abs(n)
+
+        while power > 0 {
+            if power & 1 == 1 {
+                res *= base
+            }
+            base *= base
+            power >>= 1
+        }
+
+        return n >= 0 ? res : 1 / res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/products-of-array-discluding-self.md b/articles/products-of-array-discluding-self.md
index 1a74a5c68..1370fac97 100644
--- a/articles/products-of-array-discluding-self.md
+++ b/articles/products-of-array-discluding-self.md
@@ -142,12 +142,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func productExceptSelf(_ nums: [Int]) -> [Int] {
+        let n = nums.count
+        var res = [Int](repeating: 0, count: n)
+
+        for i in 0..<n {
+            var prod = 1
+            for j in 0..<n {
+                if i == j {
+                    continue
+                }
+                prod *= nums[j]
+            }
+            res[i] = prod
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n ^ 2)$
-* Space complexity: $O(1)$ since the output array is excluded from space analysis.
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output array.
+
 ---
 
 ## 2. Division
@@ -356,12 +381,46 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func productExceptSelf(_ nums: [Int]) -> [Int] {
+        var prod = 1
+        var zeroCount = 0
+
+        for num in nums {
+            if num != 0 {
+                prod *= num
+            } else {
+                zeroCount += 1
+            }
+        }
+        
+        if zeroCount > 1 {
+            return [Int](repeating: 0, count: nums.count)
+        }
+
+        var res = [Int](repeating: 0, count: nums.count)
+        for (i, num) in nums.enumerated() {
+            if zeroCount > 0 {
+                res[i] = num == 0 ? prod : 0
+            } else {
+                res[i] = prod / num
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n)$
-* Space complexity: $O(1)$ since the output array is excluded from space analysis.
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output array.
 
 ---
 
@@ -533,6 +592,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func productExceptSelf(_ nums: [Int]) -> [Int] {
+        let n = nums.count
+        var res = [Int](repeating: 0, count: n)
+        var pref = [Int](repeating: 0, count: n)
+        var suff = [Int](repeating: 0, count: n)
+
+        pref[0] = 1
+        suff[n - 1] = 1
+
+        for i in 1..<n {
+            pref[i] = nums[i - 1] * pref[i - 1]
+        }
+        
+        for i in stride(from: n - 2, through: 0, by: -1) {
+            suff[i] = nums[i + 1] * suff[i + 1]
+        }
+        
+        for i in 0..<n {
+            res[i] = pref[i] * suff[i]
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -694,9 +781,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func productExceptSelf(_ nums: [Int]) -> [Int] {
+        var res = [Int](repeating: 1, count: nums.count)
+
+        var prefix = 1
+        for i in 0..<nums.count {
+            res[i] = prefix
+            prefix *= nums[i]
+        }
+
+        var postfix = 1
+        for i in stride(from: nums.count - 1, through: 0, by: -1) {
+            res[i] *= postfix
+            postfix *= nums[i]
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n)$
-* Space complexity: $O(1)$ since the output array is excluded from space analysis.
\ No newline at end of file
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output array.
\ No newline at end of file
diff --git a/articles/reconstruct-flight-path.md b/articles/reconstruct-flight-path.md
index b76aff7a7..26ca58784 100644
--- a/articles/reconstruct-flight-path.md
+++ b/articles/reconstruct-flight-path.md
@@ -283,6 +283,46 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findItinerary(_ tickets: [[String]]) -> [String] {
+        var adj = [String: [String]]()
+        for ticket in tickets {
+            adj[ticket[0], default: []].append(ticket[1])
+        }
+
+        for key in adj.keys {
+            adj[key]?.sort()
+        }
+
+        var res = ["JFK"]
+
+        func dfs(_ src: String) -> Bool {
+            if res.count == tickets.count + 1 {
+                return true
+            }
+            guard let destinations = adj[src] else {
+                return false
+            }
+
+            var temp = destinations
+            for i in 0..<temp.count {
+                let v = temp[i]
+                adj[src]?.remove(at: i)
+                res.append(v)
+                if dfs(v) { return true }
+                res.removeLast()
+                adj[src]?.insert(v, at: i)
+            }
+            return false
+        }
+
+        dfs("JFK")
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -502,6 +542,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findItinerary(_ tickets: [[String]]) -> [String] {
+        var adj = [String: [String]]()
+        for ticket in tickets.sorted(by: { $0[1] > $1[1] }) {
+            adj[ticket[0], default: []].append(ticket[1])
+        }
+
+        var res = [String]()
+
+        func dfs(_ src: String) {
+            while let destinations = adj[src], !destinations.isEmpty {
+                let dst = adj[src]!.removeLast()
+                dfs(dst)
+            }
+            res.append(src)
+        }
+
+        dfs("JFK")
+        return res.reversed()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -718,6 +782,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findItinerary(_ tickets: [[String]]) -> [String] {
+        var adj = [String: [String]]()
+        for ticket in tickets.sorted(by: { $0[1] > $1[1] }) {
+            adj[ticket[0], default: []].append(ticket[1])
+        }
+
+        var stack = ["JFK"]
+        var res = [String]()
+
+        while !stack.isEmpty {
+            let curr = stack.last!
+            if adj[curr] == nil || adj[curr]!.isEmpty {
+                res.append(stack.removeLast())
+            } else {
+                stack.append(adj[curr]!.removeLast())
+            }
+        }
+
+        return res.reversed()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/redundant-connection.md b/articles/redundant-connection.md
index 81a67ff84..154493da7 100644
--- a/articles/redundant-connection.md
+++ b/articles/redundant-connection.md
@@ -247,6 +247,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findRedundantConnection(_ edges: [[Int]]) -> [Int] {
+        let n = edges.count
+        var adj = Array(repeating: [Int](), count: n + 1)
+
+        func dfs(_ node: Int, _ par: Int, _ visit: inout [Bool]) -> Bool {
+            if visit[node] {
+                return true
+            }
+
+            visit[node] = true
+            for nei in adj[node] {
+                if nei == par {
+                    continue
+                }
+                if dfs(nei, node, &visit) {
+                    return true
+                }
+            }
+            return false
+        }
+
+        for edge in edges {
+            let u = edge[0]
+            let v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+            var visit = Array(repeating: false, count: n + 1)
+
+            if dfs(u, -1, &visit) {
+                return [u, v]
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -606,6 +645,62 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findRedundantConnection(_ edges: [[Int]]) -> [Int] {
+        let n = edges.count
+        var adj = Array(repeating: [Int](), count: n + 1)
+        
+        for edge in edges {
+            let u = edge[0]
+            let v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+        }
+
+        var visit = Array(repeating: false, count: n + 1)
+        var cycle = Set<Int>()
+        var cycleStart = -1
+
+        func dfs(_ node: Int, _ par: Int) -> Bool {
+            if visit[node] {
+                cycleStart = node
+                return true
+            }
+            
+            visit[node] = true
+            for nei in adj[node] {
+                if nei == par {
+                    continue
+                }
+                if dfs(nei, node) {
+                    if cycleStart != -1 {
+                        cycle.insert(node)
+                    }
+                    if node == cycleStart {
+                        cycleStart = -1
+                    }
+                    return true
+                }
+            }
+            return false
+        }
+
+        dfs(1, -1)
+
+        for edge in edges.reversed() {
+            let u = edge[0]
+            let v = edge[1]
+            if cycle.contains(u) && cycle.contains(v) {
+                return [u, v]
+            }
+        }
+
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -895,6 +990,52 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findRedundantConnection(_ edges: [[Int]]) -> [Int] {
+        let n = edges.count
+        var indegree = Array(repeating: 0, count: n + 1)
+        var adj = Array(repeating: [Int](), count: n + 1)
+
+        for edge in edges {
+            let u = edge[0]
+            let v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+            indegree[u] += 1
+            indegree[v] += 1
+        }
+
+        var queue = Deque<Int>()
+        for i in 1...n {
+            if indegree[i] == 1 {
+                queue.append(i)
+            }
+        }
+
+        while !queue.isEmpty {
+            let node = queue.popFirst()!
+            indegree[node] -= 1
+            for nei in adj[node] {
+                indegree[nei] -= 1
+                if indegree[nei] == 1 {
+                    queue.append(nei)
+                }
+            }
+        }
+
+        for edge in edges.reversed() {
+            let u = edge[0]
+            let v = edge[1]
+            if indegree[u] == 2 && indegree[v] > 0 {
+                return [u, v]
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1212,6 +1353,50 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findRedundantConnection(_ edges: [[Int]]) -> [Int] {
+        var par = Array(0...edges.count)
+        var rank = Array(repeating: 1, count: edges.count + 1)
+
+        func find(_ n: Int) -> Int {
+            var p = par[n]
+            while p != par[p] {
+                par[p] = par[par[p]]
+                p = par[p]
+            }
+            return p
+        }
+
+        func union(_ n1: Int, _ n2: Int) -> Bool {
+            let p1 = find(n1)
+            let p2 = find(n2)
+
+            if p1 == p2 {
+                return false
+            }
+            if rank[p1] > rank[p2] {
+                par[p2] = p1
+                rank[p1] += rank[p2]
+            } else {
+                par[p1] = p2
+                rank[p2] += rank[p1]
+            }
+            return true
+        }
+
+        for edge in edges {
+            let n1 = edge[0]
+            let n2 = edge[1]
+            if !union(n1, n2) {
+                return [n1, n2]
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/regular-expression-matching.md b/articles/regular-expression-matching.md
index 31b2a26a4..fd4bfda86 100644
--- a/articles/regular-expression-matching.md
+++ b/articles/regular-expression-matching.md
@@ -184,6 +184,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isMatch(_ s: String, _ p: String) -> Bool {
+        let sArr = Array(s), pArr = Array(p)
+        let m = sArr.count, n = pArr.count
+
+        func dfs(_ i: Int, _ j: Int) -> Bool {
+            if j == n {
+                return i == m
+            }
+
+            let match = i < m && (sArr[i] == pArr[j] || pArr[j] == ".")
+
+            if j + 1 < n && pArr[j + 1] == "*" {
+                return dfs(i, j + 2) || (match && dfs(i + 1, j))
+            }
+
+            if match {
+                return dfs(i + 1, j + 1)
+            }
+
+            return false
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -432,6 +461,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isMatch(_ s: String, _ p: String) -> Bool {
+        let sArr = Array(s), pArr = Array(p)
+        let m = sArr.count, n = pArr.count
+        var cache = [[Bool?]](repeating: [Bool?](repeating: nil, count: n + 1), count: m + 1)
+
+        func dfs(_ i: Int, _ j: Int) -> Bool {
+            if j == n {
+                return i == m
+            }
+            if let cached = cache[i][j] {
+                return cached
+            }
+
+            let match = i < m && (sArr[i] == pArr[j] || pArr[j] == ".")
+
+            if j + 1 < n && pArr[j + 1] == "*" {
+                cache[i][j] = dfs(i, j + 2) || (match && dfs(i + 1, j))
+                return cache[i][j]!
+            }
+
+            if match {
+                cache[i][j] = dfs(i + 1, j + 1)
+                return cache[i][j]!
+            }
+
+            cache[i][j] = false
+            return false
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -635,6 +700,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isMatch(_ s: String, _ p: String) -> Bool {
+        let sArr = Array(s), pArr = Array(p)
+        let m = sArr.count, n = pArr.count
+        var dp = Array(repeating: Array(repeating: false, count: n + 1), count: m + 1)
+        dp[m][n] = true
+
+        for i in stride(from: m, through: 0, by: -1) {
+            for j in stride(from: n - 1, through: 0, by: -1) {
+                let match = i < m && (sArr[i] == pArr[j] || pArr[j] == ".")
+
+                if j + 1 < n && pArr[j + 1] == "*" {
+                    dp[i][j] = dp[i][j + 2]
+                    if match {
+                        dp[i][j] = dp[i][j] || dp[i + 1][j]
+                    }
+                } else if match {
+                    dp[i][j] = dp[i + 1][j + 1]
+                }
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -862,6 +955,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isMatch(_ s: String, _ p: String) -> Bool {
+        let sArr = Array(s), pArr = Array(p)
+        var dp = Array(repeating: false, count: pArr.count + 1)
+        dp[pArr.count] = true
+        
+        for i in stride(from: sArr.count, through: 0, by: -1) {
+            var nextDp = Array(repeating: false, count: pArr.count + 1)
+            nextDp[pArr.count] = (i == sArr.count)
+
+            for j in stride(from: pArr.count - 1, through: 0, by: -1) {
+                let match = i < sArr.count && (sArr[i] == pArr[j] || pArr[j] == ".")
+
+                if j + 1 < pArr.count && pArr[j + 1] == "*" {
+                    nextDp[j] = nextDp[j + 2]
+                    if match {
+                        nextDp[j] = nextDp[j] || dp[j]
+                    }
+                } else if match {
+                    nextDp[j] = dp[j + 1]
+                }
+            }
+
+            dp = nextDp
+        }
+        
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1096,6 +1221,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isMatch(_ s: String, _ p: String) -> Bool {
+        let sArr = Array(s)
+        let pArr = Array(p)
+        var dp = [Bool](repeating: false, count: pArr.count + 1)
+        dp[pArr.count] = true
+
+        for i in stride(from: sArr.count, through: 0, by: -1) {
+            var dp1 = dp[pArr.count]
+            dp[pArr.count] = (i == sArr.count)
+
+            for j in stride(from: pArr.count - 1, through: 0, by: -1) {
+                let match = i < sArr.count && (sArr[i] == pArr[j] || pArr[j] == ".")
+                var res = false
+                if j + 1 < pArr.count && pArr[j + 1] == "*" {
+                    res = dp[j + 2]
+                    if match {
+                        res = res || dp[j]
+                    }
+                } else if match {
+                    res = dp1
+                }
+                dp1 = dp[j]
+                dp[j] = res
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/remove-node-from-end-of-linked-list.md b/articles/remove-node-from-end-of-linked-list.md
index 141817504..ee936f416 100644
--- a/articles/remove-node-from-end-of-linked-list.md
+++ b/articles/remove-node-from-end-of-linked-list.md
@@ -216,6 +216,38 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
+        var nodes: [ListNode] = []
+        var cur = head
+
+        while cur != nil {
+            nodes.append(cur!)
+            cur = cur?.next
+        }
+
+        let removeIndex = nodes.count - n
+        if removeIndex == 0 {
+            return head?.next
+        }
+
+        nodes[removeIndex - 1].next = nodes[removeIndex].next
+        return head
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -490,6 +522,44 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
+        var N = 0
+        var cur = head
+        while cur != nil {
+            N += 1
+            cur = cur?.next
+        }
+
+        let removeIndex = N - n
+        if removeIndex == 0 {
+            return head?.next
+        }
+
+        cur = head
+        for i in 0..<(N - 1) {
+            if (i + 1) == removeIndex {
+                cur?.next = cur?.next?.next
+                break
+            }
+            cur = cur?.next
+        }
+        return head
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -723,12 +793,44 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func rec(_ head: ListNode?, _ n: inout Int) -> ListNode? {
+        if head == nil {
+            return nil
+        }
+
+        head?.next = rec(head?.next, &n)
+        n -= 1
+        if n == 0 {
+            return head?.next
+        }
+        return head
+    }
+
+    func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
+        var n = n
+        return rec(head, &n)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(N)$
-* Space complexity: $O(N)$
+* Space complexity: $O(N)$ for recursion stack.
 
 ---
 
@@ -964,6 +1066,40 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
+        let dummy = ListNode(0, head)
+        var left: ListNode? = dummy
+        var right: ListNode? = head
+        var n = n
+
+        while n > 0 {
+            right = right?.next
+            n -= 1
+        }
+
+        while right != nil {
+            left = left?.next
+            right = right?.next
+        }
+
+        left?.next = left?.next?.next
+        return dummy.next
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reorder-linked-list.md b/articles/reorder-linked-list.md
index 399860a22..75e0ef82c 100644
--- a/articles/reorder-linked-list.md
+++ b/articles/reorder-linked-list.md
@@ -260,6 +260,47 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reorderList(_ head: ListNode?) {
+        if head == nil {
+            return
+        }
+        
+        var nodes: [ListNode] = []
+        var cur = head
+        
+        while cur != nil {
+            nodes.append(cur!)
+            cur = cur?.next
+        }
+        
+        var i = 0, j = nodes.count - 1
+        while i < j {
+            nodes[i].next = nodes[j]
+            i += 1
+            if i >= j {
+                break
+            }
+            nodes[j].next = nodes[i]
+            j -= 1
+        }
+        
+        nodes[i].next = nil
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -286,10 +327,11 @@ class Solution:
         def rec(root: ListNode, cur: ListNode) -> ListNode:
             if not cur:
                 return root
-            root = rec(root, cur.next)
 
+            root = rec(root, cur.next)
             if not root:
                 return None
+
             tmp = None
             if root == cur or root.next == cur:
                 cur.next = None
@@ -297,8 +339,9 @@ class Solution:
                 tmp = root.next
                 root.next = cur
                 cur.next = tmp
+
             return tmp
-            
+
         head = rec(head, head.next)
 ```
 
@@ -323,10 +366,12 @@ public class Solution {
         if (cur == null) {
             return root;
         }
+
         root = rec(root, cur.next);
         if (root == null) {
             return null;
         }
+
         ListNode tmp = null;
         if (root == cur || root.next == cur) {
             cur.next = null;
@@ -335,6 +380,7 @@ public class Solution {
             root.next = cur;
             cur.next = tmp;
         }
+
         return tmp;
     }
 }
@@ -363,10 +409,12 @@ private:
         if (cur == nullptr) {
             return root;
         }
+
         root = rec(root, cur->next);
         if (root == nullptr) {
             return nullptr;
         }
+
         ListNode* tmp = nullptr;
         if (root == cur || root->next == cur) {
             cur->next = nullptr;
@@ -375,6 +423,7 @@ private:
             root->next = cur;
             cur->next = tmp;
         }
+
         return tmp;
     }
 };
@@ -409,10 +458,12 @@ class Solution {
         if (cur === null) {
             return root;
         }
+
         root = this.rec(root, cur.next);
         if (root === null) {
             return null;
         }
+
         let tmp = null;
         if (root === cur || root.next === cur) {
             cur.next = null;
@@ -421,6 +472,7 @@ class Solution {
             root.next = cur;
             cur.next = tmp;
         }
+
         return tmp;
     }
 }
@@ -448,10 +500,12 @@ public class Solution {
         if (cur == null) {
             return root;
         }
+
         root = Rec(root, cur.next);
         if (root == null) {
             return null;
         }
+
         ListNode tmp = null;
         if (root == cur || root.next == cur) {
             cur.next = null;
@@ -460,6 +514,7 @@ public class Solution {
             root.next = cur;
             cur.next = tmp;
         }
+
         return tmp;
     }
 }
@@ -483,11 +538,12 @@ func reorderList(head *ListNode) {
         if cur == nil {
             return root
         }
-        root = rec(root, cur.Next)
 
+        root = rec(root, cur.Next)
         if root == nil {
             return nil
         }
+
         var tmp *ListNode
         if root == cur || root.Next == cur {
             cur.Next = nil
@@ -496,6 +552,7 @@ func reorderList(head *ListNode) {
             root.Next = cur
             cur.Next = tmp
         }
+
         return tmp
     }
 
@@ -521,11 +578,12 @@ class Solution {
             if (cur == null) {
                 return root
             }
-            var updatedRoot = rec(root, cur.next)
 
+            var updatedRoot = rec(root, cur.next)
             if (updatedRoot == null) {
                 return null
             }
+
             var tmp: ListNode? = null
             if (updatedRoot == cur || updatedRoot?.next == cur) {
                 cur.next = null
@@ -534,6 +592,7 @@ class Solution {
                 updatedRoot.next = cur
                 cur.next = tmp
             }
+
             return tmp
         }
 
@@ -542,6 +601,46 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reorderList(_ head: ListNode?) {
+        func rec(_ root: ListNode?, _ cur: ListNode?) -> ListNode? {
+            if cur == nil {
+                return root
+            }
+
+            var root = rec(root, cur?.next)
+            if root == nil {
+                return nil
+            }
+
+            var tmp: ListNode? = nil
+            if root === cur || root?.next === cur {
+                cur?.next = nil
+            } else {
+                tmp = root?.next
+                root?.next = cur
+                cur?.next = tmp
+            }
+
+            return tmp
+        }
+        
+        rec(head, head?.next)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -852,6 +951,51 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reorderList(_ head: ListNode?) {
+        var slow = head, fast = head?.next
+        while fast != nil && fast?.next != nil {
+            slow = slow?.next
+            fast = fast?.next?.next
+        }
+
+        var second = slow?.next
+        var prev: ListNode? = nil
+        slow?.next = nil
+
+        while second != nil {
+            let tmp = second?.next
+            second?.next = prev
+            prev = second
+            second = tmp
+        }
+
+        var first = head
+        second = prev
+
+        while second != nil {
+            let tmp1 = first?.next
+            let tmp2 = second?.next
+            first?.next = second
+            second?.next = tmp1
+            first = tmp1
+            second = tmp2
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reverse-a-linked-list.md b/articles/reverse-a-linked-list.md
index 98f5ee98d..3a205a543 100644
--- a/articles/reverse-a-linked-list.md
+++ b/articles/reverse-a-linked-list.md
@@ -200,6 +200,35 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reverseList(_ head: ListNode?) -> ListNode? {
+        if head == nil {
+            return nil
+        }
+
+        var newHead = head
+        if head?.next != nil {
+            newHead = reverseList(head?.next)
+            head?.next?.next = head
+        }
+        head?.next = nil
+
+        return newHead
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -397,6 +426,33 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reverseList(_ head: ListNode?) -> ListNode? {
+        var prev: ListNode? = nil
+        var curr = head
+
+        while curr != nil {
+            let temp = curr?.next
+            curr?.next = prev
+            prev = curr
+            curr = temp
+        }
+        return prev
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reverse-bits.md b/articles/reverse-bits.md
index d5267bf19..84cbe88ce 100644
--- a/articles/reverse-bits.md
+++ b/articles/reverse-bits.md
@@ -162,6 +162,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func reverseBits(_ n: Int) -> Int {
+        var binary = ""
+        for i in 0..<32 {
+            if (n & (1 << i)) != 0 {
+                binary += "1"
+            } else {
+                binary += "0"
+            }
+        }
+
+        var res = 0
+        for (i, bit) in binary.reversed().enumerated() {
+            if bit == "1" {
+                res |= (1 << i)
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -266,6 +290,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func reverseBits(_ n: Int) -> Int {
+        var res = 0
+        var num = n
+        for i in 0..<32 {
+            let bit = (num >> i) & 1
+            res |= (bit << (31 - i))
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -378,6 +416,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func reverseBits(_ n: Int) -> Int {
+        var res = n
+        res = (res >> 16) | (res << 16) & 0xFFFFFFFF
+        res = ((res & 0xff00ff00) >> 8) | ((res & 0x00ff00ff) << 8)
+        res = ((res & 0xf0f0f0f0) >> 4) | ((res & 0x0f0f0f0f) << 4)
+        res = ((res & 0xcccccccc) >> 2) | ((res & 0x33333333) << 2)
+        res = ((res & 0xaaaaaaaa) >> 1) | ((res & 0x55555555) << 1)
+        return res & 0xFFFFFFFF
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reverse-integer.md b/articles/reverse-integer.md
index f6d060a33..c388a821f 100644
--- a/articles/reverse-integer.md
+++ b/articles/reverse-integer.md
@@ -147,6 +147,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func reverse(_ x: Int) -> Int {
+        let org = x
+        var x = abs(x)
+        var res = Int(String(String(x).reversed()))!
+
+        if org < 0 {
+            res *= -1
+        }
+        if res < Int32.min || res > Int32.max {
+            return 0
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -310,6 +329,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func reverse(_ x: Int) -> Int {
+        func rec(_ n: Int, _ rev: Int) -> Int {
+            if n == 0 {
+                return rev
+            }
+            return rec(n / 10, rev * 10 + n % 10)
+        }
+
+        let sign = x < 0 ? -1 : 1
+        let reversedNum = rec(abs(x), 0) * sign
+
+        if reversedNum < Int32.min || reversedNum > Int32.max {
+            return 0
+        }
+
+        return reversedNum
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -489,6 +530,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func reverse(_ x: Int) -> Int {
+        let MIN = Int32.min
+        let MAX = Int32.max
+
+        var res = 0
+        var num = x
+
+        while num != 0 {
+            let digit = num % 10
+            num /= 10
+
+            if res > MAX / 10 || (res == MAX / 10 && digit > MAX % 10) {
+                return 0
+            }
+            if res < MIN / 10 || (res == MIN / 10 && digit < MIN % 10) {
+                return 0
+            }
+            res = res * 10 + digit
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reverse-nodes-in-k-group.md b/articles/reverse-nodes-in-k-group.md
index ad54de13e..f5836142d 100644
--- a/articles/reverse-nodes-in-k-group.md
+++ b/articles/reverse-nodes-in-k-group.md
@@ -251,6 +251,47 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
+        var cur = head
+        var group = 0
+
+        while cur != nil && group < k {
+            cur = cur!.next
+            group += 1
+        }
+
+        if group == k {
+            cur = reverseKGroup(cur, k)
+
+            var tempHead = head
+            while group > 0 {
+                let tmp = tempHead!.next
+                tempHead!.next = cur
+                cur = tempHead
+                tempHead = tmp
+                group -= 1
+            }
+
+            return cur
+        }
+
+        return head
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -603,6 +644,57 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
+        let dummy = ListNode(0, head)
+        var groupPrev: ListNode? = dummy
+
+        while true {
+            guard let kth = getKth(groupPrev, k) else {
+                break
+            }
+            let groupNext = kth.next
+
+            var prev: ListNode? = kth.next
+            var curr = groupPrev?.next
+
+            while curr !== groupNext {
+                let tmp = curr?.next
+                curr?.next = prev
+                prev = curr
+                curr = tmp
+            }
+
+            let tmp = groupPrev?.next
+            groupPrev?.next = kth
+            groupPrev = tmp
+        }
+        return dummy.next
+    }
+
+    private func getKth(_ curr: ListNode?, _ k: Int) -> ListNode? {
+        var curr = curr
+        var k = k
+        while curr != nil && k > 0 {
+            curr = curr?.next
+            k -= 1
+        }
+        return curr
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/rotate-matrix.md b/articles/rotate-matrix.md
index 2f050d984..c7ea787f1 100644
--- a/articles/rotate-matrix.md
+++ b/articles/rotate-matrix.md
@@ -145,6 +145,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rotate(_ matrix: inout [[Int]]) {
+        let n = matrix.count
+        var rotated = Array(repeating: Array(repeating: 0, count: n), count: n)
+
+        for i in 0..<n {
+            for j in 0..<n {
+                rotated[j][n - 1 - i] = matrix[i][j]
+            }
+        }
+
+        for i in 0..<n {
+            for j in 0..<n {
+                matrix[i][j] = rotated[i][j]
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -384,6 +405,38 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rotate(_ matrix: inout [[Int]]) {
+        var l = 0
+        var r = matrix.count - 1
+        while l < r {
+            for i in 0..<r - l {
+                let top = l
+                let bottom = r
+
+                // save the topleft
+                let topLeft = matrix[top][l + i]
+
+                // move bottom left into top left
+                matrix[top][l + i] = matrix[bottom - i][l]
+
+                // move bottom right into bottom left
+                matrix[bottom - i][l] = matrix[bottom][r - i]
+
+                // move top right into bottom right
+                matrix[bottom][r - i] = matrix[top + i][r]
+
+                // move top left into top right
+                matrix[top + i][r] = topLeft
+            }
+            r -= 1
+            l += 1
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -522,6 +575,22 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func rotate(_ matrix: inout [[Int]]) {
+        // Reverse the matrix vertically
+        matrix.reverse()
+
+        // Transpose the matrix
+        for i in 0..<matrix.count {
+            for j in i + 1..<matrix.count {
+                (matrix[i][j], matrix[j][i]) = (matrix[j][i], matrix[i][j])
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/rotting-fruit.md b/articles/rotting-fruit.md
index 33f3162a0..62345eea7 100644
--- a/articles/rotting-fruit.md
+++ b/articles/rotting-fruit.md
@@ -334,6 +334,54 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func orangesRotting(_ grid: [[Int]]) -> Int {
+        var grid = grid
+        var queue = Deque<(Int, Int)>()
+        var fresh = 0
+        var time = 0
+
+        let ROWS = grid.count
+        let COLS = grid[0].count
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == 1 {
+                    fresh += 1
+                }
+                if grid[r][c] == 2 {
+                    queue.append((r, c))
+                }
+            }
+        }
+
+        let directions = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+
+        while fresh > 0 && !queue.isEmpty {
+            let length = queue.count
+            for _ in 0..<length {
+                let (r, c) = queue.popFirst()!
+
+                for dir in directions {
+                    let row = r + dir[0]
+                    let col = c + dir[1]
+
+                    if row >= 0 && row < ROWS && col >= 0 && col < COLS && grid[row][col] == 1 {
+                        grid[row][col] = 2
+                        queue.append((row, col))
+                        fresh -= 1
+                    }
+                }
+            }
+            time += 1
+        }
+
+        return fresh == 0 ? time : -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -704,6 +752,64 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func orangesRotting(_ grid: [[Int]]) -> Int {
+        var grid = grid
+        let ROWS = grid.count
+        let COLS = grid[0].count
+        var fresh = 0
+        var time = 0
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if grid[r][c] == 1 {
+                    fresh += 1
+                }
+            }
+        }
+
+        let directions = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+
+        while fresh > 0 {
+            var flag = false
+            for r in 0..<ROWS {
+                for c in 0..<COLS {
+                    if grid[r][c] == 2 {
+                        for dir in directions {
+                            let row = r + dir[0]
+                            let col = c + dir[1]
+                            if (row >= 0 && row < ROWS && col >= 0 &&
+                                col < COLS && grid[row][col] == 1) {
+                                grid[row][col] = 3
+                                fresh -= 1
+                                flag = true
+                            }
+                        }
+                    }
+                }
+            }
+
+            if !flag {
+                return -1
+            }
+
+            for r in 0..<ROWS {
+                for c in 0..<COLS {
+                    if grid[r][c] == 3 {
+                        grid[r][c] = 2
+                    }
+                }
+            }
+
+            time += 1
+        }
+
+        return time
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/same-binary-tree.md b/articles/same-binary-tree.md
index aa0f1a59a..b07d14e35 100644
--- a/articles/same-binary-tree.md
+++ b/articles/same-binary-tree.md
@@ -186,6 +186,36 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isSameTree(_ p: TreeNode?, _ q: TreeNode?) -> Bool {
+        if p == nil && q == nil {
+            return true
+        }
+        if let p = p, let q = q, p.val == q.val {
+            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)
+        } else {
+            return false
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -444,6 +474,45 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isSameTree(_ p: TreeNode?, _ q: TreeNode?) -> Bool {
+        var stack: [(TreeNode?, TreeNode?)] = [(p, q)]
+
+        while !stack.isEmpty {
+            let (node1, node2) = stack.removeLast()
+
+            if node1 == nil && node2 == nil {
+                continue
+            }
+            if node1 == nil || node2 == nil || node1!.val != node2!.val {
+                return false
+            }
+
+            stack.append((node1!.right, node2!.right))
+            stack.append((node1!.left, node2!.left))
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -742,6 +811,51 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isSameTree(_ p: TreeNode?, _ q: TreeNode?) -> Bool {
+        var q1 = Deque<TreeNode?>()
+        var q2 = Deque<TreeNode?>()
+        q1.append(p)
+        q2.append(q)
+
+        while !q1.isEmpty && !q2.isEmpty {
+            let nodeP = q1.removeFirst()
+            let nodeQ = q2.removeFirst()
+
+            if nodeP == nil && nodeQ == nil {
+                continue
+            }
+            if nodeP == nil || nodeQ == nil || nodeP!.val != nodeQ!.val {
+                return false
+            }
+
+            q1.append(nodeP!.left)
+            q1.append(nodeP!.right)
+            q2.append(nodeQ!.left)
+            q2.append(nodeQ!.right)
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/search-2d-matrix.md b/articles/search-2d-matrix.md
index 722cbe2b6..45181e5df 100644
--- a/articles/search-2d-matrix.md
+++ b/articles/search-2d-matrix.md
@@ -106,6 +106,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func searchMatrix(_ matrix: [[Int]], _ target: Int) -> Bool {
+        for r in 0..<matrix.count {
+            for c in 0..<matrix[0].count {
+                if matrix[r][c] == target {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -263,6 +278,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func searchMatrix(_ matrix: [[Int]], _ target: Int) -> Bool {
+        let m = matrix.count
+        let n = matrix[0].count
+        var r = 0, c = n - 1
+
+        while r < m && c >= 0 {
+            if matrix[r][c] > target {
+                c -= 1
+            } else if matrix[r][c] < target {
+                r += 1
+            } else {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -546,6 +582,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func searchMatrix(_ matrix: [[Int]], _ target: Int) -> Bool {
+        let ROWS = matrix.count
+        let COLS = matrix[0].count
+
+        var top = 0, bot = ROWS - 1
+        while top <= bot {
+            let row = (top + bot) / 2
+            if target > matrix[row][COLS - 1] {
+                top = row + 1
+            } else if target < matrix[row][0] {
+                bot = row - 1
+            } else {
+                break
+            }
+        }
+
+        if !(top <= bot) {
+            return false
+        }
+        let row = (top + bot) / 2
+        var l = 0, r = COLS - 1
+        while l <= r {
+            let m = (l + r) / 2
+            if target > matrix[row][m] {
+                l = m + 1
+            } else if target < matrix[row][m] {
+                r = m - 1
+            } else {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -718,6 +792,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func searchMatrix(_ matrix: [[Int]], _ target: Int) -> Bool {
+        let ROWS = matrix.count
+        let COLS = matrix[0].count
+
+        var l = 0, r = ROWS * COLS - 1
+        while l <= r {
+            let m = l + (r - l) / 2
+            let row = m / COLS
+            let col = m % COLS
+
+            if target > matrix[row][col] {
+                l = m + 1
+            } else if target < matrix[row][col] {
+                r = m - 1
+            } else {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/search-for-word-ii.md b/articles/search-for-word-ii.md
index d304ea983..519307f04 100644
--- a/articles/search-for-word-ii.md
+++ b/articles/search-for-word-ii.md
@@ -282,6 +282,53 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findWords(_ board: [[Character]], _ words: [String]) -> [String] {
+        let ROWS = board.count
+        let COLS = board[0].count
+        var res: [String] = []
+        var board = board
+
+        func backtrack(_ r: Int, _ c: Int, _ i: Int, _ word: [Character]) -> Bool {
+            if i == word.count {
+                return true
+            }
+            if r < 0 || c < 0 || r >= ROWS || c >= COLS || board[r][c] != word[i] {
+                return false
+            }
+
+            board[r][c] = "*"
+            let ret = backtrack(r + 1, c, i + 1, word) ||
+                      backtrack(r - 1, c, i + 1, word) ||
+                      backtrack(r, c + 1, i + 1, word) ||
+                      backtrack(r, c - 1, i + 1, word)
+            board[r][c] = word[i]
+            return ret
+        }
+
+        for word in words {
+            var flag = false
+            let wordArray = Array(word)
+            for r in 0..<ROWS {
+                if flag { break }
+                for c in 0..<COLS {
+                    if board[r][c] != wordArray[0] {
+                        continue
+                    }
+                    if backtrack(r, c, 0, wordArray) {
+                        res.append(word)
+                        flag = true
+                        break
+                    }
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -347,7 +394,7 @@ class Solution:
 ```
 
 ```java
-public class TrieNode {
+class TrieNode {
     Map<Character, TrieNode> children;
     boolean isWord;
 
@@ -743,6 +790,68 @@ class Solution {
 }
 ```
 
+```swift
+class TrieNode {
+    var children: [Character: TrieNode] = [:]
+    var isWord: Bool = false
+    
+    func addWord(_ word: String) {
+        var current = self
+        for char in word {
+            if current.children[char] == nil {
+                current.children[char] = TrieNode()
+            }
+            current = current.children[char]!
+        }
+        current.isWord = true
+    }
+}
+
+class Solution {
+    func findWords(_ board: [[Character]], _ words: [String]) -> [String] {
+        let root = TrieNode()
+        for word in words {
+            root.addWord(word)
+        }
+        
+        let ROWS = board.count
+        let COLS = board[0].count
+        var result = Set<String>()
+        var visited = Set<[Int]>()
+        
+        func dfs(_ r: Int, _ c: Int, _ node: TrieNode, _ word: String) {
+            if r < 0 || c < 0 || r >= ROWS || c >= COLS || 
+               visited.contains([r, c]) || node.children[board[r][c]] == nil {
+                return
+            }
+            
+            visited.insert([r, c])
+            let nextNode = node.children[board[r][c]]!
+            let newWord = word + String(board[r][c])
+            
+            if nextNode.isWord {
+                result.insert(newWord)
+            }
+            
+            dfs(r + 1, c, nextNode, newWord)
+            dfs(r - 1, c, nextNode, newWord)
+            dfs(r, c + 1, nextNode, newWord)
+            dfs(r, c - 1, nextNode, newWord)
+            
+            visited.remove([r, c])
+        }
+        
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                dfs(r, c, root, "")
+            }
+        }
+        
+        return Array(result)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -824,7 +933,7 @@ class Solution:
 ```
 
 ```java
-public class TrieNode {
+class TrieNode {
     TrieNode[] children = new TrieNode[26];
     int idx = -1;
     int refs = 0;
@@ -1291,6 +1400,85 @@ class Solution {
 }
 ```
 
+```swift
+class TrieNode {
+    var children: [TrieNode?] = Array(repeating: nil, count: 26)
+    var idx: Int = -1
+    var refs: Int = 0
+    
+    func addWord(_ word: String, _ i: Int) {
+        var cur = self
+        cur.refs += 1
+        for c in word {
+            let index = Int(c.asciiValue! - Character("a").asciiValue!)
+            if cur.children[index] == nil {
+                cur.children[index] = TrieNode()
+            }
+            cur = cur.children[index]!
+            cur.refs += 1
+        }
+        cur.idx = i
+    }
+}
+
+class Solution {
+    func findWords(_ board: [[Character]], _ words: [String]) -> [String] {
+        let root = TrieNode()
+        for i in 0..<words.count {
+            root.addWord(words[i], i)
+        }
+        
+        let ROWS = board.count
+        let COLS = board[0].count
+        var res: [String] = []
+        var boardCopy = board
+        
+        func getIndex(_ c: Character) -> Int {
+            return Int(c.asciiValue! - Character("a").asciiValue!)
+        }
+        
+        func dfs(_ r: Int, _ c: Int, _ node: TrieNode) {
+            if r < 0 || c < 0 || r >= ROWS || c >= COLS || 
+               boardCopy[r][c] == "*" || 
+               node.children[getIndex(boardCopy[r][c])] == nil {
+                return
+            }
+            
+            let tmp = boardCopy[r][c]
+            boardCopy[r][c] = "*"
+            let prev = node
+            let nextNode = node.children[getIndex(tmp)]!
+            
+            if nextNode.idx != -1 {
+                res.append(words[nextNode.idx])
+                nextNode.idx = -1
+                nextNode.refs -= 1
+                if nextNode.refs == 0 {
+                    prev.children[getIndex(tmp)] = nil
+                    boardCopy[r][c] = tmp
+                    return
+                }
+            }
+            
+            dfs(r + 1, c, nextNode)
+            dfs(r - 1, c, nextNode)
+            dfs(r, c + 1, nextNode)
+            dfs(r, c - 1, nextNode)
+            
+            boardCopy[r][c] = tmp
+        }
+        
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                dfs(r, c, root)
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/search-for-word.md b/articles/search-for-word.md
index 93fd51588..bb2895568 100644
--- a/articles/search-for-word.md
+++ b/articles/search-for-word.md
@@ -268,6 +268,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func exist(_ board: [[Character]], _ word: String) -> Bool {
+        let ROWS = board.count
+        let COLS = board[0].count
+        var path = Set<[Int]>()
+        let wordArray = Array(word)
+
+        func dfs(_ r: Int, _ c: Int, _ i: Int) -> Bool {
+            if i == wordArray.count {
+                return true
+            }
+            if (r < 0 || c < 0 || r >= ROWS || c >= COLS ||
+                board[r][c] != wordArray[i] || path.contains([r, c])) {
+                return false
+            }
+
+            path.insert([r, c])
+            let res = dfs(r + 1, c, i + 1) ||
+                      dfs(r - 1, c, i + 1) ||
+                      dfs(r, c + 1, i + 1) ||
+                      dfs(r, c - 1, i + 1)
+            path.remove([r, c])
+            return res
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if dfs(r, c, 0) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -551,6 +589,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func exist(_ board: [[Character]], _ word: String) -> Bool {
+        let ROWS = board.count
+        let COLS = board[0].count
+        var visited = Array(repeating: Array(repeating: false, count: COLS), count: ROWS)
+        let wordArray = Array(word)
+
+        func dfs(_ r: Int, _ c: Int, _ i: Int) -> Bool {
+            if i == wordArray.count {
+                return true
+            }
+            if (r < 0 || c < 0 || r >= ROWS || c >= COLS ||
+                board[r][c] != wordArray[i] || visited[r][c]) {
+                return false
+            }
+
+            visited[r][c] = true
+            let res = dfs(r + 1, c, i + 1) ||
+                      dfs(r - 1, c, i + 1) ||
+                      dfs(r, c + 1, i + 1) ||
+                      dfs(r, c - 1, i + 1)
+            visited[r][c] = false
+            return res
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if dfs(r, c, 0) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -817,6 +893,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func exist(_ board: [[Character]], _ word: String) -> Bool {
+        let ROWS = board.count
+        let COLS = board[0].count
+        let wordArray = Array(word)
+        var board = board
+
+        func dfs(_ r: Int, _ c: Int, _ i: Int) -> Bool {
+            if i == wordArray.count {
+                return true
+            }
+            if (r < 0 || c < 0 || r >= ROWS || c >= COLS ||
+                board[r][c] != wordArray[i] || board[r][c] == "#") {
+                return false
+            }
+
+            let temp = board[r][c]
+            board[r][c] = "#"
+            let res = dfs(r + 1, c, i + 1) ||
+                      dfs(r - 1, c, i + 1) ||
+                      dfs(r, c + 1, i + 1) ||
+                      dfs(r, c - 1, i + 1)
+            board[r][c] = temp
+            return res
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if dfs(r, c, 0) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/serialize-and-deserialize-binary-tree.md b/articles/serialize-and-deserialize-binary-tree.md
index 01a3b0d41..ad965e002 100644
--- a/articles/serialize-and-deserialize-binary-tree.md
+++ b/articles/serialize-and-deserialize-binary-tree.md
@@ -401,6 +401,61 @@ class Codec {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.left = nil
+ *         self.right = nil
+ *     }
+ * }
+ */
+
+class Codec {
+
+    func serialize(_ root: TreeNode?) -> String {
+        var res = [String]()
+
+        func dfs(_ node: TreeNode?) {
+            guard let node = node else {
+                res.append("N")
+                return
+            }
+            res.append("\(node.val)")
+            dfs(node.left)
+            dfs(node.right)
+        }
+
+        dfs(root)
+        return res.joined(separator: ",")
+    }
+
+    func deserialize(_ data: String) -> TreeNode? {
+        var vals = data.split(separator: ",").map { String($0) }
+        var i = 0
+
+        func dfs() -> TreeNode? {
+            if vals[i] == "N" {
+                i += 1
+                return nil
+            }
+            let node = TreeNode(Int(vals[i])!)
+            i += 1
+            node.left = dfs()
+            node.right = dfs()
+            return node
+        }
+
+        return dfs()
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -863,6 +918,76 @@ class Codec {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.left = nil
+ *         self.right = nil
+ *     }
+ * }
+ */
+
+class Codec {
+
+    func serialize(_ root: TreeNode?) -> String {
+        guard let root = root else {
+            return "N"
+        }
+
+        var res = [String]()
+        var queue: Deque<TreeNode?> = [root]
+
+        while !queue.isEmpty {
+            let node = queue.removeFirst()
+            if let node = node {
+                res.append("\(node.val)")
+                queue.append(node.left)
+                queue.append(node.right)
+            } else {
+                res.append("N")
+            }
+        }
+
+        return res.joined(separator: ",")
+    }
+
+    func deserialize(_ data: String) -> TreeNode? {
+        let vals = data.split(separator: ",").map { String($0) }
+        guard vals[0] != "N" else {
+            return nil
+        }
+
+        let root = TreeNode(Int(vals[0])!)
+        var queue: Deque<TreeNode> = [root]
+        var index = 1
+
+        while !queue.isEmpty {
+            let node = queue.popFirst()!
+            
+            if vals[index] != "N" {
+                node.left = TreeNode(Int(vals[index])!)
+                queue.append(node.left!)
+            }
+            index += 1
+
+            if vals[index] != "N" {
+                node.right = TreeNode(Int(vals[index])!)
+                queue.append(node.right!)
+            }
+            index += 1
+        }
+
+        return root
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/set-zeroes-in-matrix.md b/articles/set-zeroes-in-matrix.md
index 5a265e1f5..72cef4283 100644
--- a/articles/set-zeroes-in-matrix.md
+++ b/articles/set-zeroes-in-matrix.md
@@ -208,6 +208,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func setZeroes(_ matrix: inout [[Int]]) {
+        let rows = matrix.count
+        let cols = matrix[0].count
+        var mark = matrix
+
+        for r in 0..<rows {
+            for c in 0..<cols {
+                if matrix[r][c] == 0 {
+                    for col in 0..<cols {
+                        mark[r][col] = 0
+                    }
+                    for row in 0..<rows {
+                        mark[row][c] = 0
+                    }
+                }
+            }
+        }
+
+        for r in 0..<rows {
+            for c in 0..<cols {
+                matrix[r][c] = mark[r][c]
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -407,6 +436,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func setZeroes(_ matrix: inout [[Int]]) {
+        let rows = matrix.count
+        let cols = matrix[0].count
+        var rowFlags = Array(repeating: false, count: rows)
+        var colFlags = Array(repeating: false, count: cols)
+
+        for r in 0..<rows {
+            for c in 0..<cols {
+                if matrix[r][c] == 0 {
+                    rowFlags[r] = true
+                    colFlags[c] = true
+                }
+            }
+        }
+
+        for r in 0..<rows {
+            for c in 0..<cols {
+                if rowFlags[r] || colFlags[c] {
+                    matrix[r][c] = 0
+                }
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -708,6 +765,49 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func setZeroes(_ matrix: inout [[Int]]) {
+        let ROWS = matrix.count
+        let COLS = matrix[0].count
+        var rowZero = false
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if matrix[r][c] == 0 {
+                    matrix[0][c] = 0
+                    if r > 0 {
+                        matrix[r][0] = 0
+                    } else {
+                        rowZero = true
+                    }
+                }
+            }
+        }
+
+        for r in 1..<ROWS {
+            for c in 1..<COLS {
+                if matrix[0][c] == 0 || matrix[r][0] == 0 {
+                    matrix[r][c] = 0
+                }
+            }
+        }
+
+        if matrix[0][0] == 0 {
+            for r in 0..<ROWS {
+                matrix[r][0] = 0
+            }
+        }
+
+        if rowZero {
+            for c in 0..<COLS {
+                matrix[0][c] = 0
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/single-number.md b/articles/single-number.md
index f46078213..8919e9baa 100644
--- a/articles/single-number.md
+++ b/articles/single-number.md
@@ -136,6 +136,26 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func singleNumber(_ nums: [Int]) -> Int {
+        for i in 0..<nums.count {
+            var flag = true
+            for j in 0..<nums.count {
+                if i != j && nums[i] == nums[j] {
+                    flag = false
+                    break
+                }
+            }
+            if flag {
+                return nums[i]
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -266,6 +286,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func singleNumber(_ nums: [Int]) -> Int {
+        var seen = Set<Int>()
+
+        for num in nums {
+            if seen.contains(num) {
+                seen.remove(num)
+            } else {
+                seen.insert(num)
+            }
+        }
+
+        return seen.first!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -397,6 +435,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func singleNumber(_ nums: [Int]) -> Int {
+        var nums = nums.sorted()
+        var i = 0
+
+        while i < nums.count - 1 {
+            if nums[i] == nums[i + 1] {
+                i += 2
+            } else {
+                return nums[i]
+            }
+        }
+
+        return nums[i]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -494,6 +551,18 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func singleNumber(_ nums: [Int]) -> Int {
+        var res = 0
+        for num in nums {
+            res ^= num
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/sliding-window-maximum.md b/articles/sliding-window-maximum.md
index c4accb268..a7af08296 100644
--- a/articles/sliding-window-maximum.md
+++ b/articles/sliding-window-maximum.md
@@ -133,12 +133,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
+        var output = [Int]()
+
+        for i in 0...(nums.count - k) {
+            var maxi = nums[i]
+            for j in i..<(i + k) {
+                maxi = max(maxi, nums[j])
+            }
+            output.append(maxi)
+        }
+
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * k)$
-* Space complexity: $O(1)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n - k + 1)$ space for the output array.
 
 > Where $n$ is the length of the array and $k$ is the size of the window.
 
@@ -537,6 +557,64 @@ class Solution {
 }
 ```
 
+```swift
+class SegmentTree {
+    private var n: Int
+    private var tree: [Int]
+
+    init(_ N: Int, _ A: [Int]) {
+        self.n = N
+        while (self.n & (self.n - 1)) != 0 {
+            self.n += 1
+        }
+        self.tree = [Int](repeating: Int.min, count: 2 * self.n)
+        build(N, A)
+    }
+
+    private func build(_ N: Int, _ A: [Int]) {
+        for i in 0..<N {
+            tree[n + i] = A[i]
+        }
+        for i in stride(from: n - 1, through: 1, by: -1) {
+            tree[i] = max(tree[i << 1], tree[i << 1 | 1])
+        }
+    }
+
+    func query(_ l: Int, _ r: Int) -> Int {
+        var res = Int.min
+        var l = l + n
+        var r = r + n + 1
+        while l < r {
+            if l & 1 != 0 {
+                res = max(res, tree[l])
+                l += 1
+            }
+            if r & 1 != 0 {
+                r -= 1
+                res = max(res, tree[r])
+            }
+            l >>= 1
+            r >>= 1
+        }
+        return res
+    }
+}
+
+class Solution {
+    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
+        let n = nums.count
+        let segTree = SegmentTree(n, nums)
+        var output = [Int]()
+
+        for i in 0...(n - k) {
+            output.append(segTree.query(i, i + k - 1))
+        }
+
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -635,8 +713,9 @@ class Solution {
 ```csharp
 public class Solution {
     public int[] MaxSlidingWindow(int[] nums, int k) {
-        PriorityQueue<(int val, int idx), int> pq = new PriorityQueue<(int val, int idx), int>
-        (Comparer<int>.Create((a, b) => b.CompareTo(a)));
+        PriorityQueue<(int val, int idx), int> pq = new PriorityQueue<(int val, int idx), int>(
+            Comparer<int>.Create((a, b) => b.CompareTo(a))
+        );
         
         int[] output = new int[nums.Length - k + 1];
         int idx = 0;
@@ -700,6 +779,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
+        var heap = Heap<Item>()
+        var output = [Int]()
+
+        for i in 0..<nums.count {
+            heap.insert(Item(num: nums[i], index: i))
+            
+            if i >= k - 1 {
+                while heap.max!.index <= i - k {
+                    heap.removeMax()
+                }
+                output.append(heap.max!.num)
+            }
+        }
+        return output
+    }
+}
+
+struct Item: Comparable {
+    let num: Int
+    let index: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.num < rhs.num
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -963,6 +1072,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
+        let n = nums.count
+        var leftMax = [Int](repeating: 0, count: n)
+        var rightMax = [Int](repeating: 0, count: n)
+
+        leftMax[0] = nums[0]
+        rightMax[n - 1] = nums[n - 1]
+
+        for i in 1..<n {
+            if i % k == 0 {
+                leftMax[i] = nums[i]
+            } else {
+                leftMax[i] = max(leftMax[i - 1], nums[i])
+            }
+
+            if (n - 1 - i) % k == 0 {
+                rightMax[n - 1 - i] = nums[n - 1 - i]
+            } else {
+                rightMax[n - 1 - i] = max(rightMax[n - i], nums[n - 1 - i])
+            }
+        }
+
+        var output = [Int](repeating: 0, count: n - k + 1)
+
+        for i in 0..<(n - k + 1) {
+            output[i] = max(leftMax[i + k - 1], rightMax[i])
+        }
+
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1182,6 +1326,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
+        var output = [Int]()
+        var deque = [Int]() // Index
+        var l = 0, r = 0
+
+        while r < nums.count {
+            while !deque.isEmpty && nums[deque.last!] < nums[r] {
+                deque.removeLast()
+            }
+            deque.append(r)
+
+            if l > deque.first! {
+                deque.removeFirst()
+            }
+
+            if (r + 1) >= k {
+                output.append(nums[deque.first!])
+                l += 1
+            }
+            r += 1
+        }
+
+        return output
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/spiral-matrix.md b/articles/spiral-matrix.md
index 7935874fc..2e82fff76 100644
--- a/articles/spiral-matrix.md
+++ b/articles/spiral-matrix.md
@@ -198,6 +198,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func spiralOrder(_ matrix: [[Int]]) -> [Int] {
+        var m = matrix.count
+        var n = matrix[0].count
+        var res: [Int] = []
+
+        // append all the elements in the given direction
+        func dfs(_ row: Int, _ col: Int, _ r: inout Int, _ c: inout Int, _ dr: Int, _ dc: Int) {
+            if row == 0 || col == 0 {
+                return
+            }
+
+            for _ in 0..<col {
+                r += dr
+                c += dc
+                res.append(matrix[r][c])
+            }
+
+            // sub-problem
+            dfs(col, row - 1, &r, &c, dc, -dr)
+        }
+
+        var r = 0
+        var c = -1
+
+        // start by going to the right
+        dfs(m, n, &r, &c, 0, 1)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -464,6 +497,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func spiralOrder(_ matrix: [[Int]]) -> [Int] {
+        var res: [Int] = []
+        var left = 0, right = matrix[0].count
+        var top = 0, bottom = matrix.count
+
+        while left < right && top < bottom {
+            for i in left..<right {
+                res.append(matrix[top][i])
+            }
+            top += 1
+            for i in top..<bottom {
+                res.append(matrix[i][right - 1])
+            }
+            right -= 1
+            if !(left < right && top < bottom) {
+                break
+            }
+            for i in stride(from: right - 1, through: left, by: -1) {
+                res.append(matrix[bottom - 1][i])
+            }
+            bottom -= 1
+            for i in stride(from: bottom - 1, through: top, by: -1) {
+                res.append(matrix[i][left])
+            }
+            left += 1
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -654,6 +721,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func spiralOrder(_ matrix: [[Int]]) -> [Int] {
+        var res: [Int] = []
+        let directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        var steps = [matrix[0].count, matrix.count - 1]
+
+        var r = 0, c = -1, d = 0
+        while steps[d & 1] > 0 {
+            for _ in 0..<steps[d & 1] {
+                r += directions[d].0
+                c += directions[d].1
+                res.append(matrix[r][c])
+            }
+            steps[d & 1] -= 1
+            d += 1
+            d %= 4
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/string-encode-and-decode.md b/articles/string-encode-and-decode.md
index b60d5115e..ca00a45b8 100644
--- a/articles/string-encode-and-decode.md
+++ b/articles/string-encode-and-decode.md
@@ -282,6 +282,56 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func encode(_ strs: [String]) -> String {
+        if strs.isEmpty { return "" }
+
+        var sizes: [Int] = []
+        var res = ""
+        for s in strs {
+            sizes.append(s.count)
+        }
+        for sz in sizes {
+            res += String(sz)
+            res += ","
+        }
+
+        res += "#"
+        for s in strs {
+            res += s
+        }
+        return res
+    }
+    
+    func decode(_ s: String) -> [String] {
+        if s.isEmpty { return [] }
+        let sArr = Array(s)
+        var sizes: [Int] = []
+        var res: [String] = []
+        var i = 0
+
+        while sArr[i] != "#" {
+            var cur = ""
+            while sArr[i] != "," {
+                cur.append(sArr[i])
+                i += 1
+            }
+            sizes.append(Int(cur)!)
+            i += 1
+        }
+
+        i += 1
+        for sz in sizes {
+            let substring = String(sArr[i..<i+sz])
+            res.append(substring)
+            i += sz
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -506,6 +556,41 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func encode(_ strs: [String]) -> String {
+        var res = ""
+        for s in strs {
+            res += "\(s.count)#\(s)"
+        }
+        return res
+    }
+    
+    func decode(_ s: String) -> [String] {
+        var res = [String]()
+        let sArr = Array(s)
+        var i = 0
+
+        while i < sArr.count {
+            var j = i
+            while sArr[j] != "#" {
+                j += 1
+            }
+            let lengthStr = String(sArr[i..<j])
+            let length = Int(lengthStr)!
+
+            i = j + 1
+            let end = i + length
+            let substring = String(sArr[i..<end])
+            res.append(substring)
+            i = end
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/subsets-ii.md b/articles/subsets-ii.md
index 7ceeedab6..fef683226 100644
--- a/articles/subsets-ii.md
+++ b/articles/subsets-ii.md
@@ -193,6 +193,31 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
+        var res = Set<[Int]>()
+        var subset = [Int]()
+        let nums = nums.sorted()
+
+        func backtrack(_ i: Int) {
+            if i == nums.count {
+                res.insert(subset)
+                return
+            }
+
+            subset.append(nums[i])
+            backtrack(i + 1)
+            subset.removeLast()
+            backtrack(i + 1)
+        }
+
+        backtrack(0)
+        return Array(res)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -202,7 +227,7 @@ class Solution {
 
 ---
 
-## 2. Backtracking (Pick / Not Pick)
+## 2. Backtracking - I
 
 ::tabs-start
 
@@ -405,16 +430,48 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var subset = [Int]()
+        let nums = nums.sorted()
+        
+        func backtrack(_ i: Int) {
+            if i == nums.count {
+                res.append(subset)
+                return
+            }
+            
+            subset.append(nums[i])
+            backtrack(i + 1)
+            subset.removeLast()
+            
+            var j = i
+            while j + 1 < nums.count && nums[j] == nums[j + 1] {
+                j += 1
+            }
+            backtrack(j + 1)
+        }
+        
+        backtrack(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(2 ^ n)$ space for the output list.
 
 ---
 
-## 3. Backtracking
+## 3. Backtracking - II
 
 ::tabs-start
 
@@ -595,12 +652,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var subset = [Int]()
+        let nums = nums.sorted()
+        
+        func backtrack(_ i: Int) {
+            res.append(subset)
+            
+            for j in i..<nums.count {
+                if j > i && nums[j] == nums[j - 1] {
+                    continue
+                }
+                subset.append(nums[j])
+                backtrack(j + 1)
+                subset.removeLast()
+            }
+        }
+        
+        backtrack(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(2 ^ n)$ space for the output list.
 
 ---
 
@@ -614,6 +699,7 @@ class Solution:
         nums.sort()
         res = [[]]
         prev_Idx = idx = 0
+
         for i in range(len(nums)):
             idx = prev_idx if i >= 1 and nums[i] == nums[i - 1] else 0
             prev_idx = len(res)
@@ -621,6 +707,7 @@ class Solution:
                 tmp = res[j].copy()
                 tmp.append(nums[i])
                 res.append(tmp)
+
         return res
 ```
 
@@ -632,6 +719,7 @@ public class Solution {
         res.add(new ArrayList<>());        
         int prevIdx = 0;
         int idx = 0;
+
         for (int i = 0; i < nums.length; i++) {
             idx = (i >= 1 && nums[i] == nums[i - 1]) ? prevIdx : 0;
             prevIdx = res.size();
@@ -641,6 +729,7 @@ public class Solution {
                 res.add(tmp);
             }
         }
+
         return res;
     }
 }
@@ -654,6 +743,7 @@ public:
         vector<vector<int>> res = {{}};
         int prevIdx = 0;
         int idx = 0;
+
         for (int i = 0; i < nums.size(); i++) {
             idx = (i >= 1 && nums[i] == nums[i - 1]) ? prevIdx : 0;
             prevIdx = res.size();
@@ -663,6 +753,7 @@ public:
                 res.push_back(tmp);
             }
         }
+
         return res;
     }
 };
@@ -679,6 +770,7 @@ class Solution {
         const res = [[]];
         let prevIdx = 0;
         let idx = 0;
+
         for (let i = 0; i < nums.length; i++) {
             idx = (i >= 1 && nums[i] === nums[i - 1]) ? prevIdx : 0;
             prevIdx = res.length;
@@ -688,6 +780,7 @@ class Solution {
                 res.push(tmp);
             }
         }
+
         return res;
     }
 }
@@ -700,6 +793,7 @@ public class Solution {
         var res = new List<List<int>> { new List<int>() };
         int prevIdx = 0;
         int idx = 0;
+
         for (int i = 0; i < nums.Length; i++) {
             idx = (i >= 1 && nums[i] == nums[i - 1]) ? prevIdx : 0;
             prevIdx = res.Count;
@@ -709,6 +803,7 @@ public class Solution {
                 res.Add(tmp);
             }
         }
+
         return res;
     }
 }
@@ -761,9 +856,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
+        let nums = nums.sorted()
+        var res: [[Int]] = [[]]
+        var prevIdx = 0
+        var idx = 0
+
+        for i in 0..<nums.count {
+            idx = (i >= 1 && nums[i] == nums[i - 1]) ? prevIdx : 0
+            prevIdx = res.count
+
+            for j in idx..<prevIdx {
+                var temp = res[j]
+                temp.append(nums[i])
+                res.append(temp)
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(1)$
\ No newline at end of file
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(2 ^ n)$ space for the output list.
\ No newline at end of file
diff --git a/articles/subsets.md b/articles/subsets.md
index 0740719c2..733609e9f 100644
--- a/articles/subsets.md
+++ b/articles/subsets.md
@@ -6,7 +6,6 @@
 class Solution:
     def subsets(self, nums: List[int]) -> List[List[int]]:
         res = []
-
         subset = []
 
         def dfs(i):
@@ -172,12 +171,37 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsets(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var subset = [Int]()
+
+        func dfs(_ i: Int) {
+            if i >= nums.count {
+                res.append(subset)
+                return
+            }
+            subset.append(nums[i])
+            dfs(i + 1)
+            subset.removeLast()
+            dfs(i + 1)
+        }
+        
+        dfs(0)
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(2 ^ n)$ for the output list.
 
 ---
 
@@ -316,12 +340,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsets(_ nums: [Int]) -> [[Int]] {
+        var res: [[Int]] = [[]]
+
+        for num in nums {
+            res += res.map { $0 + [num] }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(2 ^ n)$ for the output list.
 
 ---
 
@@ -461,9 +501,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func subsets(_ nums: [Int]) -> [[Int]] {
+        let n = nums.count
+        var res: [[Int]] = []
+
+        for i in 0..<(1 << n) {
+            var subset: [Int] = []
+            for j in 0..<n {
+                if (i & (1 << j)) != 0 {
+                    subset.append(nums[j])
+                }
+            }
+            res.append(subset)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n * 2 ^ n)$
-* Space complexity: $O(n)$
\ No newline at end of file
+* Space complexity:
+    * $O(n)$ extra space.
+    * $O(2 ^ n)$ for the output list.
\ No newline at end of file
diff --git a/articles/subtree-of-a-binary-tree.md b/articles/subtree-of-a-binary-tree.md
index 3b88e53d9..f4e7e57f2 100644
--- a/articles/subtree-of-a-binary-tree.md
+++ b/articles/subtree-of-a-binary-tree.md
@@ -294,6 +294,48 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isSubtree(_ root: TreeNode?, _ subRoot: TreeNode?) -> Bool {
+        if subRoot == nil {
+            return true
+        }
+        if root == nil {
+            return false
+        }
+        if sameTree(root, subRoot) {
+            return true
+        }
+        return isSubtree(root?.left, subRoot) || isSubtree(root?.right, subRoot)
+    }
+
+    func sameTree(_ root: TreeNode?, _ subRoot: TreeNode?) -> Bool {
+        if root == nil && subRoot == nil {
+            return true
+        }
+        if let root = root, let subRoot = subRoot, root.val == subRoot.val {
+            return sameTree(root.left, subRoot.left) && sameTree(root.right, subRoot.right)
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -319,11 +361,10 @@ class Solution {
 
 class Solution: 
     def serialize(self, root: Optional[TreeNode]) -> str:
-            if root == None:
-                return "$#"
-            
-            return ("$" + str(root.val) + 
-                    self.serialize(root.left) + self.serialize(root.right))  
+        if root == None:
+            return "$#"
+
+        return ("$" + str(root.val) + self.serialize(root.left) + self.serialize(root.right))  
 
     def z_function(self, s: str) -> list:
         z = [0] * len(s)
@@ -341,10 +382,10 @@ class Solution:
         serialized_root = self.serialize(root)
         serialized_subRoot = self.serialize(subRoot)
         combined = serialized_subRoot + "|" + serialized_root
-        
+
         z_values = self.z_function(combined)
         sub_len = len(serialized_subRoot)
-        
+
         for i in range(sub_len + 1, len(combined)):
             if z_values[i] == sub_len:
                 return True
@@ -492,8 +533,7 @@ class Solution {
         if (root === null) {
             return "$#";
         }
-        return "$" + root.val + 
-                this.serialize(root.left) + this.serialize(root.right);
+        return "$" + root.val + this.serialize(root.left) + this.serialize(root.right);
     }
 
     /**
@@ -714,6 +754,69 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func serialize(_ root: TreeNode?) -> String {
+        guard let root = root else {
+            return "$#"
+        }
+        return "$\(root.val)" + serialize(root.left) + serialize(root.right)
+    }
+
+    func zFunction(_ s: String) -> [Int] {
+        let n = s.count
+        var z = [Int](repeating: 0, count: n)
+        var l = 0, r = 0
+        let chars = Array(s)
+
+        for i in 1..<n {
+            if i <= r {
+                z[i] = min(r - i + 1, z[i - l])
+            }
+            while i + z[i] < n && chars[z[i]] == chars[i + z[i]] {
+                z[i] += 1
+            }
+            if i + z[i] - 1 > r {
+                l = i
+                r = i + z[i] - 1
+            }
+        }
+        return z
+    }
+
+    func isSubtree(_ root: TreeNode?, _ subRoot: TreeNode?) -> Bool {
+        let serializedRoot = serialize(root)
+        let serializedSubRoot = serialize(subRoot)
+        let combined = serializedSubRoot + "|" + serializedRoot
+
+        let zValues = zFunction(combined)
+        let subLen = serializedSubRoot.count
+
+        for i in (subLen + 1)..<combined.count {
+            if zValues[i] == subLen {
+                return true
+            }
+        }
+        return false
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/sum-of-two-integers.md b/articles/sum-of-two-integers.md
index 4fffcb35f..6d43c0a14 100644
--- a/articles/sum-of-two-integers.md
+++ b/articles/sum-of-two-integers.md
@@ -60,6 +60,14 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func getSum(_ a: Int, _ b: Int) -> Int {
+        return a + b
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -250,6 +258,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func getSum(_ a: Int, _ b: Int) -> Int {
+        var carry = 0
+        var res = 0
+        let mask = 0xFFFFFFFF
+
+        for i in 0..<32 {
+            let aBit = (a >> i) & 1
+            let bBit = (b >> i) & 1
+            let curBit = aBit ^ bBit ^ carry
+            carry = (aBit + bBit + carry) >= 2 ? 1 : 0
+            if curBit == 1 {
+                res |= (1 << i)
+            }
+        }
+
+        if res > 0x7FFFFFFF {
+            res = ~(res ^ mask)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -379,6 +413,25 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func getSum(_ a: Int, _ b: Int) -> Int {
+        let mask = 0xFFFFFFFF
+        let maxInt = 0x7FFFFFFF
+        var a = a
+        var b = b
+
+        while b != 0 {
+            let carry = (a & b) << 1
+            a = (a ^ b) & mask
+            b = carry & mask
+        }
+
+        return a <= maxInt ? a : ~(a ^ mask)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/surrounded-regions.md b/articles/surrounded-regions.md
index f1009a0bc..1c0c5445c 100644
--- a/articles/surrounded-regions.md
+++ b/articles/surrounded-regions.md
@@ -330,6 +330,54 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func solve(_ board: inout [[Character]]) {
+        let ROWS = board.count
+        let COLS = board[0].count
+
+        func capture(_ r: Int, _ c: Int) {
+            if r < 0 || c < 0 || r == ROWS || c == COLS || board[r][c] != "O" {
+                return
+            }
+            board[r][c] = "T"
+            capture(r + 1, c)
+            capture(r - 1, c)
+            capture(r, c + 1)
+            capture(r, c - 1)
+        }
+
+        for r in 0..<ROWS {
+            if board[r][0] == "O" {
+                capture(r, 0)
+            }
+            if board[r][COLS - 1] == "O" {
+                capture(r, COLS - 1)
+            }
+        }
+
+        for c in 0..<COLS {
+            if board[0][c] == "O" {
+                capture(0, c)
+            }
+            if board[ROWS - 1][c] == "O" {
+                capture(ROWS - 1, c)
+            }
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if board[r][c] == "O" {
+                    board[r][c] = "X"
+                } else if board[r][c] == "T" {
+                    board[r][c] = "O"
+                }
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -496,7 +544,7 @@ class Solution {
         let directions = [[1, 0], [-1, 0], [0, 1], [0, -1]];
         
         const capture = () => {
-            let q = [];
+            let q = new Queue();
             for (let r = 0; r < ROWS; r++) {
                 for (let c = 0; c < COLS; c++) {
                     if (r === 0 || r === ROWS - 1 || 
@@ -506,8 +554,8 @@ class Solution {
                     }
                 }
             }
-            while (q.length) {
-                let [r, c] = q.shift();
+            while (!q.isEmpty()) {
+                let [r, c] = q.pop();
                 if (board[r][c] === 'O') {
                     board[r][c] = 'T';
                     for (let [dr, dc] of directions) {
@@ -684,6 +732,53 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func solve(_ board: inout [[Character]]) {
+        let ROWS = board.count
+        let COLS = board[0].count
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+
+        func capture() {
+            var queue = Deque<(Int, Int)>()
+            for r in 0..<ROWS {
+                for c in 0..<COLS {
+                    if (r == 0 || r == ROWS - 1 || c == 0 || c == COLS - 1) && board[r][c] == "O" {
+                        queue.append((r, c))
+                    }
+                }
+            }
+
+            while !queue.isEmpty {
+                let (r, c) = queue.popFirst()!
+                if board[r][c] == "O" {
+                    board[r][c] = "T"
+                    for dir in directions {
+                        let nr = r + dir.0
+                        let nc = c + dir.1
+                        if nr >= 0, nr < ROWS, nc >= 0, nc < COLS {
+                            queue.append((nr, nc))
+                        }
+                    }
+                }
+            }
+        }
+
+        capture()
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if board[r][c] == "O" {
+                    board[r][c] = "X"
+                } else if board[r][c] == "T" {
+                    board[r][c] = "O"
+                }
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -753,7 +848,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     int[] Parent, Size;
 
     public DSU(int n) {
@@ -1208,6 +1303,79 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    private var parent: [Int]
+    private var size: [Int]
+
+    init(_ n: Int) {
+        parent = Array(0...n)
+        size = Array(repeating: 1, count: n + 1)
+    }
+
+    func find(_ node: Int) -> Int {
+        if parent[node] != node {
+            parent[node] = find(parent[node])
+        }
+        return parent[node]
+    }
+
+    func union(_ u: Int, _ v: Int) {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv { return }
+        if size[pu] >= size[pv] {
+            size[pu] += size[pv]
+            parent[pv] = pu
+        } else {
+            size[pv] += size[pu]
+            parent[pu] = pv
+        }
+    }
+
+    func connected(_ u: Int, _ v: Int) -> Bool {
+        return find(u) == find(v)
+    }
+}
+
+class Solution {
+    func solve(_ board: inout [[Character]]) {
+        let ROWS = board.count
+        let COLS = board[0].count
+        let directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+        let dsu = DSU(ROWS * COLS + 1)
+        let N = ROWS * COLS
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if board[r][c] != "O" {
+                    continue
+                }
+                if r == 0 || c == 0 || r == ROWS - 1 || c == COLS - 1 {
+                    dsu.union(N, r * COLS + c)
+                } else {
+                    for dir in directions {
+                        let nr = r + dir.0
+                        let nc = c + dir.1
+                        if nr >= 0, nr < ROWS, nc >= 0, nc < COLS, board[nr][nc] == "O" {
+                            dsu.union(r * COLS + c, nr * COLS + nc)
+                        }
+                    }
+                }
+            }
+        }
+
+        for r in 0..<ROWS {
+            for c in 0..<COLS {
+                if board[r][c] == "O", !dsu.connected(N, r * COLS + c) {
+                    board[r][c] = "X"
+                }
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/swim-in-rising-water.md b/articles/swim-in-rising-water.md
index 820592628..b87262dcb 100644
--- a/articles/swim-in-rising-water.md
+++ b/articles/swim-in-rising-water.md
@@ -232,6 +232,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func swimInWater(_ grid: [[Int]]) -> Int {
+        let n = grid.count
+        var visit = Array(repeating: Array(repeating: false, count: n), count: n)
+
+        func dfs(_ node: (Int, Int), _ t: Int) -> Int {
+            let (r, c) = node
+            if r < 0 || c < 0 || r >= n || c >= n || visit[r][c] {
+                return 1000000
+            }
+            if r == n - 1 && c == n - 1 {
+                return max(t, grid[r][c])
+            }
+            visit[r][c] = true
+            let t = max(t, grid[r][c])
+            let res = min(dfs((r + 1, c), t),
+                          dfs((r - 1, c), t),
+                          dfs((r, c + 1), t),
+                          dfs((r, c - 1), t))
+            visit[r][c] = false
+            return res
+        }
+
+        return dfs((0, 0), 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -544,6 +573,51 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func swimInWater(_ grid: [[Int]]) -> Int {
+        let n = grid.count
+        var visit = Array(repeating: Array(repeating: false, count: n), count: n)
+        var minH = grid[0][0], maxH = grid[0][0]
+
+        for row in 0..<n {
+            for col in 0..<n {
+                maxH = max(maxH, grid[row][col])
+                minH = min(minH, grid[row][col])
+            }
+        }
+
+        func dfs(_ node: (Int, Int), _ t: Int) -> Bool {
+            let (r, c) = node
+            if r < 0 || c < 0 || r >= n || c >= n || visit[r][c] || grid[r][c] > t {
+                return false
+            }
+            if r == n - 1 && c == n - 1 {
+                return true
+            }
+            visit[r][c] = true
+            return dfs((r + 1, c), t) ||
+                   dfs((r - 1, c), t) ||
+                   dfs((r, c + 1), t) ||
+                   dfs((r, c - 1), t)
+        }
+
+        for t in minH...maxH {
+            if dfs((0, 0), t) {
+                return t
+            }
+            for r in 0..<n {
+                for c in 0..<n {
+                    visit[r][c] = false
+                }
+            }
+        }
+
+        return maxH
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -887,6 +961,55 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func swimInWater(_ grid: [[Int]]) -> Int {
+        let n = grid.count
+        var visit = Array(repeating: Array(repeating: false, count: n), count: n)
+        var minH = grid[0][0], maxH = grid[0][0]
+
+        for row in 0..<n {
+            for col in 0..<n {
+                maxH = max(maxH, grid[row][col])
+                minH = min(minH, grid[row][col])
+            }
+        }
+
+        func dfs(_ node: (Int, Int), _ t: Int) -> Bool {
+            let (r, c) = node
+            if r < 0 || c < 0 || r >= n || c >= n || visit[r][c] || grid[r][c] > t {
+                return false
+            }
+            if r == n - 1 && c == n - 1 {
+                return true
+            }
+            visit[r][c] = true
+            return dfs((r + 1, c), t) ||
+                   dfs((r - 1, c), t) ||
+                   dfs((r, c + 1), t) ||
+                   dfs((r, c - 1), t)
+        }
+
+        var l = minH, r = maxH
+        while l < r {
+            let m = (l + r) >> 1
+            if dfs((0, 0), m) {
+                r = m
+            } else {
+                l = m + 1
+            }
+            for row in 0..<n {
+                for col in 0..<n {
+                    visit[row][col] = false
+                }
+            }
+        }
+
+        return r
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1175,6 +1298,51 @@ class Solution {
 }
 ```
 
+```swift
+struct Item: Comparable {
+    let time: Int
+    let row: Int
+    let col: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.time < rhs.time
+    }
+}
+
+class Solution {
+    func swimInWater(_ grid: [[Int]]) -> Int {
+        let N = grid.count
+        var visit = Set<[Int]>()
+        var minHeap = Heap<Item>()
+
+        let directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
+
+        minHeap.insert(Item(time: grid[0][0], row: 0, col: 0))
+        visit.insert([0, 0])
+
+        while !minHeap.isEmpty {
+            let item = minHeap.removeMin()
+            let t = item.time, r = item.row, c = item.col
+
+            if r == N - 1 && c == N - 1 {
+                return t
+            }
+
+            for (dr, dc) in directions {
+                let neiR = r + dr, neiC = c + dc
+                if neiR < 0 || neiC < 0 || neiR == N || neiC == N || visit.contains([neiR, neiC]) {
+                    continue
+                }
+                visit.insert([neiR, neiC])
+                minHeap.insert(Item(time: max(t, grid[neiR][neiC]), row: neiR, col: neiC))
+            }
+        }
+
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1230,7 +1398,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     private int[] Parent;
     private int[] Size;
 
@@ -1625,6 +1793,75 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    private var parent: [Int]
+    private var size: [Int]
+
+    init(_ n: Int) {
+        parent = Array(0...(n - 1))
+        size = Array(repeating: 1, count: n)
+    }
+
+    func find(_ node: Int) -> Int {
+        if parent[node] != node {
+            parent[node] = find(parent[node])
+        }
+        return parent[node]
+    }
+
+    func union(_ u: Int, _ v: Int) -> Bool {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv {
+            return false
+        }
+        if size[pu] < size[pv] {
+            parent[pu] = pv
+            size[pv] += size[pu]
+        } else {
+            parent[pv] = pu
+            size[pu] += size[pv]
+        }
+        return true
+    }
+
+    func connected(_ u: Int, _ v: Int) -> Bool {
+        return find(u) == find(v)
+    }
+}
+
+class Solution {
+    func swimInWater(_ grid: [[Int]]) -> Int {
+        let N = grid.count
+        let dsu = DSU(N * N)
+        var positions = [(Int, Int, Int)]()
+        let directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+
+        for r in 0..<N {
+            for c in 0..<N {
+                positions.append((grid[r][c], r, c))
+            }
+        }
+
+        positions.sort { $0.0 < $1.0 }
+
+        for (t, r, c) in positions {
+            for (dr, dc) in directions {
+                let nr = r + dr, nc = c + dc
+                if nr >= 0, nc >= 0, nr < N, nc < N, grid[nr][nc] <= t {
+                    dsu.union(r * N + c, nr * N + nc)
+                }
+            }
+            if dsu.connected(0, N * N - 1) {
+                return t
+            }
+        }
+        return -1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/target-sum.md b/articles/target-sum.md
index 819f11b56..71c10c0c2 100644
--- a/articles/target-sum.md
+++ b/articles/target-sum.md
@@ -120,6 +120,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findTargetSumWays(_ nums: [Int], _ target: Int) -> Int {
+        func backtrack(_ i: Int, _ total: Int) -> Int {
+            if i == nums.count {
+                return total == target ? 1 : 0
+            }
+            return backtrack(i + 1, total + nums[i]) + backtrack(i + 1, total - nums[i])
+        }
+        return backtrack(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -331,6 +345,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findTargetSumWays(_ nums: [Int], _ target: Int) -> Int {
+        let totalSum = nums.reduce(0, +)
+        var dp = Array(repeating: Array(repeating: Int.min, count: 2 * totalSum + 1), count: nums.count)
+
+        func backtrack(_ i: Int, _ total: Int) -> Int {
+            if i == nums.count {
+                return total == target ? 1 : 0
+            }
+            if dp[i][total + totalSum] != Int.min {
+                return dp[i][total + totalSum]
+            }
+            dp[i][total + totalSum] = backtrack(i + 1, total + nums[i]) + 
+                                      backtrack(i + 1, total - nums[i])
+            return dp[i][total + totalSum]
+        }
+
+        return backtrack(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -502,6 +539,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findTargetSumWays(_ nums: [Int], _ target: Int) -> Int {
+        let n = nums.count
+        var dp = Array(repeating: [Int: Int](), count: n + 1)
+        dp[0][0] = 1
+
+        for i in 0..<n {
+            for (total, count) in dp[i] {
+                dp[i + 1][total + nums[i], default: 0] += count
+                dp[i + 1][total - nums[i], default: 0] += count
+            }
+        }
+        return dp[n][target, default: 0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -671,6 +726,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func findTargetSumWays(_ nums: [Int], _ target: Int) -> Int {
+        var dp = [0: 1]
+
+        for num in nums {
+            var nextDp = [Int: Int]()
+            for (total, count) in dp {
+                nextDp[total + num, default: 0] += count
+                nextDp[total - num, default: 0] += count
+            }
+            dp = nextDp
+        }
+        return dp[target, default: 0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/task-scheduling.md b/articles/task-scheduling.md
index d6718ba3f..03e752212 100644
--- a/articles/task-scheduling.md
+++ b/articles/task-scheduling.md
@@ -330,6 +330,50 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func leastInterval(_ tasks: [Character], _ n: Int) -> Int {
+        var count = [Int](repeating: 0, count: 26)
+        for task in tasks {
+            count[Int(task.asciiValue! - Character("A").asciiValue!)] += 1
+        }
+
+        var arr = [(Int, Int)]()
+        for i in 0..<26 {
+            if count[i] > 0 {
+                arr.append((count[i], i))
+            }
+        }
+
+        var time = 0
+        var processed = [Int]()
+
+        while !arr.isEmpty {
+            var maxi = -1
+            for i in 0..<arr.count {
+                if processed[max(0, time - n)..<time].allSatisfy({ $0 != arr[i].1 }) {
+                    if maxi == -1 || arr[maxi].0 < arr[i].0 {
+                        maxi = i
+                    }
+                }
+            }
+
+            time += 1
+            var cur = -1
+            if maxi != -1 {
+                cur = arr[maxi].1
+                arr[maxi].0 -= 1
+                if arr[maxi].0 == 0 {
+                    arr.remove(at: maxi)
+                }
+            }
+            processed.append(cur)
+        }
+        return time
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -604,6 +648,39 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func leastInterval(_ tasks: [Character], _ n: Int) -> Int {
+        var count = [Character: Int]()
+        for task in tasks {
+            count[task, default: 0] += 1
+        }
+
+        var maxHeap = Heap<Int>(Array(count.values))
+        var time = 0
+        var queue = Deque<(Int, Int)>()
+
+        while !maxHeap.isEmpty || !queue.isEmpty {
+            time += 1
+            if maxHeap.isEmpty {
+                time = queue.first!.1
+            } else {
+                let cnt = maxHeap.popMax()! - 1
+                if cnt > 0 {
+                    queue.append((cnt, time + n))
+                }
+            }
+            if let front = queue.first, front.1 == time {
+                maxHeap.insert(front.0)
+                queue.removeFirst()
+            }
+        }
+
+        return time
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -775,6 +852,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func leastInterval(_ tasks: [Character], _ n: Int) -> Int {
+        var count = [Int](repeating: 0, count: 26)
+        for task in tasks {
+            count[Int(task.asciiValue! - Character("A").asciiValue!)] += 1
+        }
+
+        count.sort()
+        let maxf = count[25]
+        var idle = (maxf - 1) * n
+
+        for i in stride(from: 24, through: 0, by: -1) {
+            idle -= min(maxf - 1, count[i])
+        }
+        
+        return max(0, idle) + tasks.count
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -951,6 +1049,28 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func leastInterval(_ tasks: [Character], _ n: Int) -> Int {
+        var count = [Int](repeating: 0, count: 26)
+        for task in tasks {
+            count[Int(task.asciiValue! - Character("A").asciiValue!)] += 1
+        }
+
+        let maxf = count.max()!
+        var maxCount = 0
+        for i in count {
+            if i == maxf {
+                maxCount += 1
+            }
+        }
+
+        let time = (maxf - 1) * (n + 1) + maxCount
+        return max(tasks.count, time)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/three-integer-sum.md b/articles/three-integer-sum.md
index 74afca85c..18b4b76b7 100644
--- a/articles/three-integer-sum.md
+++ b/articles/three-integer-sum.md
@@ -145,6 +145,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        var res = Set<[Int]>()
+        let nums = nums.sorted()
+        
+        for i in 0..<nums.count {
+            for j in (i + 1)..<nums.count {
+                for k in (j + 1)..<nums.count {
+                    if nums[i] + nums[j] + nums[k] == 0 {
+                        let tmp = [nums[i], nums[j], nums[k]]
+                        res.insert(tmp)
+                    }
+                }
+            }
+        }
+        return Array(res)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -398,6 +419,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        var nums = nums.sorted()
+        var count = [Int: Int]()
+        for num in nums {
+            count[num, default: 0] += 1
+        }
+
+        var res = [[Int]]()
+        for i in 0..<nums.count {
+            count[nums[i]]! -= 1
+            if i > 0 && nums[i] == nums[i - 1] {
+                continue
+            }
+            
+            for j in (i + 1)..<nums.count {
+                count[nums[j]]! -= 1
+                if j > i + 1 && nums[j] == nums[j - 1] {
+                    continue
+                }
+                let target = -(nums[i] + nums[j])
+                if let cnt = count[target], cnt > 0 {
+                    res.append([nums[i], nums[j], target])
+                }
+            }
+
+            for j in (i + 1)..<nums.count {
+                count[nums[j]]! += 1
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -646,9 +703,50 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]]()
+        var nums = nums.sorted()
+
+        for i in 0..<nums.count {
+            let a = nums[i]
+            if a > 0 {
+                break
+            }
+            if i > 0 && a == nums[i - 1] {
+                continue
+            }
+
+            var l = i + 1, r = nums.count - 1
+            while l < r {
+                let threeSum = a + nums[l] + nums[r]
+                if threeSum > 0 {
+                    r -= 1
+                } else if threeSum < 0 {
+                    l += 1
+                } else {
+                    res.append([a, nums[l], nums[r]])
+                    l += 1
+                    r -= 1
+                    while l < r && nums[l] == nums[l - 1] {
+                        l += 1
+                    }
+                }
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
 
 * Time complexity: $O(n ^ 2)$
-* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
\ No newline at end of file
+* Space complexity:
+    * $O(1)$ or $O(n)$ extra space depending on the sorting algorithm.
+    * $O(m)$ space for the output list.
+
+> Where $m$ is the number of triplets and $n$ is the length of the given array.
\ No newline at end of file
diff --git a/articles/time-based-key-value-store.md b/articles/time-based-key-value-store.md
index bfdc75b3e..8fc87e0e5 100644
--- a/articles/time-based-key-value-store.md
+++ b/articles/time-based-key-value-store.md
@@ -244,6 +244,40 @@ class TimeMap() {
 }
 ```
 
+```swift
+class TimeMap {
+    private var keyStore: [String: [Int: [String]]]
+
+    init() {
+        self.keyStore = [:]
+    }
+
+    func set(_ key: String, _ value: String, _ timestamp: Int) {
+        if keyStore[key] == nil {
+            keyStore[key] = [:]
+        }
+        if keyStore[key]![timestamp] == nil {
+            keyStore[key]![timestamp] = []
+        }
+        keyStore[key]![timestamp]!.append(value)
+    }
+
+    func get(_ key: String, _ timestamp: Int) -> String {
+        guard let timeMap = keyStore[key] else {
+            return ""
+        }
+
+        var seen = 0
+        for time in timeMap.keys {
+            if time <= timestamp {
+                seen = max(seen, time)
+            }
+        }
+        return seen == 0 ? "" : timeMap[seen]!.last!
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -458,6 +492,44 @@ class TimeMap() {
 }
 ```
 
+```swift
+class TimeMap {
+    private var m: [String: [(Int, String)]]
+
+    init() {
+        self.m = [:]
+    }
+
+    func set(_ key: String, _ value: String, _ timestamp: Int) {
+        if m[key] == nil {
+            m[key] = []
+        }
+        m[key]!.append((timestamp, value))
+    }
+
+    func get(_ key: String, _ timestamp: Int) -> String {
+        guard let timestamps = m[key] else {
+            return ""
+        }
+        
+        var l = 0, r = timestamps.count - 1
+        var res = ""
+
+        while l <= r {
+            let mid = (l + r) / 2
+            if timestamps[mid].0 <= timestamp {
+                res = timestamps[mid].1
+                l = mid + 1
+            } else {
+                r = mid - 1
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -739,6 +811,44 @@ class TimeMap() {
 }
 ```
 
+```swift
+class TimeMap {
+    private var keyStore: [String: [(String, Int)]]
+
+    init() {
+        self.keyStore = [:]
+    }
+
+    func set(_ key: String, _ value: String, _ timestamp: Int) {
+        if keyStore[key] == nil {
+            keyStore[key] = []
+        }
+        keyStore[key]!.append((value, timestamp))
+    }
+
+    func get(_ key: String, _ timestamp: Int) -> String {
+        guard let values = keyStore[key] else {
+            return ""
+        }
+        
+        var res = ""
+        var l = 0, r = values.count - 1
+
+        while l <= r {
+            let m = (l + r) / 2
+            if values[m].1 <= timestamp {
+                res = values[m].0
+                l = m + 1
+            } else {
+                r = m - 1
+            }
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/top-k-elements-in-list.md b/articles/top-k-elements-in-list.md
index ae16871e1..7bca2df74 100644
--- a/articles/top-k-elements-in-list.md
+++ b/articles/top-k-elements-in-list.md
@@ -156,6 +156,30 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var count = [Int: Int]()
+        for num in nums {
+            count[num, default: 0] += 1
+        }
+
+        var arr = [(Int, Int)]()
+        for (num, cnt) in count {
+            arr.append((cnt, num))
+        }
+        arr.sort { $0.0 < $1.0 }
+
+        var res = [Int]()
+        while res.count < k {
+            res.append(arr.removeLast().1)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -165,7 +189,7 @@ class Solution {
 
 ---
 
-## 2. Heap
+## 2. Min-Heap
 
 ::tabs-start
 
@@ -352,6 +376,41 @@ class Solution {
 }
 ```
 
+```swift
+struct NumFreq: Comparable {
+    let num: Int
+    let freq: Int
+
+    static func < (lhs: NumFreq, rhs: NumFreq) -> Bool {
+        return lhs.freq < rhs.freq
+    }
+}
+
+class Solution {
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var count = [Int: Int]()
+        for num in nums {
+            count[num, default: 0] += 1
+        }
+
+        var heap: Heap<NumFreq> = []        
+        for (num, freq) in count {
+            heap.insert(NumFreq(num: num, freq: freq))
+            if heap.count > k {
+                heap.removeMin()
+            }
+        }
+
+        var res = [Int]()
+        while !heap.isEmpty {
+            res.append(heap.removeMin().num)
+        }
+
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -564,6 +623,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var count = [Int: Int]()
+        var freq = [[Int]](repeating: [], count: nums.count + 1)
+        
+        for num in nums {
+            count[num, default: 0] += 1
+        }
+        
+        for (num, cnt) in count {
+            freq[cnt].append(num)
+        }
+        
+        var res = [Int]()
+        for i in stride(from: freq.count - 1, through: 1, by: -1) {
+            for num in freq[i] {
+                res.append(num)
+                if res.count == k {
+                    return res
+                }
+            }
+        }
+        
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/trapping-rain-water.md b/articles/trapping-rain-water.md
index 73635a85d..4e8f600b8 100644
--- a/articles/trapping-rain-water.md
+++ b/articles/trapping-rain-water.md
@@ -197,6 +197,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func trap(_ height: [Int]) -> Int {
+        if height.isEmpty {
+            return 0
+        }
+        let n = height.count
+        var res = 0
+
+        for i in 0..<n {
+            var leftMax = height[i]
+            var rightMax = height[i]
+
+            for j in 0..<i {
+                leftMax = max(leftMax, height[j])
+            }
+            for j in (i + 1)..<n {
+                rightMax = max(rightMax, height[j])
+            }
+
+            res += min(leftMax, rightMax) - height[i]
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -429,6 +456,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func trap(_ height: [Int]) -> Int {
+        let n = height.count
+        if n == 0 {
+            return 0
+        }
+
+        var leftMax = [Int](repeating: 0, count: n)
+        var rightMax = [Int](repeating: 0, count: n)
+
+        leftMax[0] = height[0]
+        for i in 1..<n {
+            leftMax[i] = max(leftMax[i - 1], height[i])
+        }
+
+        rightMax[n - 1] = height[n - 1]
+        for i in stride(from: n - 2, through: 0, by: -1) {
+            rightMax[i] = max(rightMax[i + 1], height[i])
+        }
+
+        var res = 0
+        for i in 0..<n {
+            res += min(leftMax[i], rightMax[i]) - height[i]
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -648,6 +705,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func trap(_ height: [Int]) -> Int {
+        if height.isEmpty {
+            return 0
+        }
+        var stack = [Int]()
+        var res = 0
+
+        for i in 0..<height.count {
+            while !stack.isEmpty && height[i] >= height[stack.last!] {
+                let mid = height[stack.removeLast()]
+                if !stack.isEmpty {
+                    let right = height[i]
+                    let left = height[stack.last!]
+                    let h = min(right, left) - mid
+                    let w = i - stack.last! - 1
+                    res += h * w
+                }
+            }
+            stack.append(i)
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -852,6 +936,33 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func trap(_ height: [Int]) -> Int {
+        if height.isEmpty {
+            return 0
+        }
+
+        var l = 0, r = height.count - 1
+        var leftMax = height[l], rightMax = height[r]
+        var res = 0
+
+        while l < r {
+            if leftMax < rightMax {
+                l += 1
+                leftMax = max(leftMax, height[l])
+                res += leftMax - height[l]
+            } else {
+                r -= 1
+                rightMax = max(rightMax, height[r])
+                res += rightMax - height[r]
+            }
+        }
+        return res
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/two-integer-sum-ii.md b/articles/two-integer-sum-ii.md
index 8aea74e9d..f63e71a60 100644
--- a/articles/two-integer-sum-ii.md
+++ b/articles/two-integer-sum-ii.md
@@ -106,6 +106,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
+        for i in 0..<numbers.count {
+            for j in (i + 1)..<numbers.count {
+                if numbers[i] + numbers[j] == target {
+                    return [i + 1, j + 1]
+                }
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -271,6 +286,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
+        for i in 0..<numbers.count {
+            var l = i + 1, r = numbers.count - 1
+            let tmp = target - numbers[i]
+
+            while l <= r {
+                let mid = l + (r - l) / 2
+                if numbers[mid] == tmp {
+                    return [i + 1, mid + 1]
+                } else if numbers[mid] < tmp {
+                    l = mid + 1
+                } else {
+                    r = mid - 1
+                }
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -396,6 +434,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
+        var mp = [Int: Int]()
+
+        for i in 0..<numbers.count {
+            let tmp = target - numbers[i]
+            if let index = mp[tmp] {
+                return [index, i + 1]
+            }
+            mp[numbers[i]] = i + 1
+        }
+
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -553,6 +609,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
+        var l = 0, r = numbers.count - 1
+
+        while l < r {
+            let curSum = numbers[l] + numbers[r]
+
+            if curSum > target {
+                r -= 1
+            } else if curSum < target {
+                l += 1
+            } else {
+                return [l + 1, r + 1]
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/two-integer-sum.md b/articles/two-integer-sum.md
index 5b08e079d..9fba0afdc 100644
--- a/articles/two-integer-sum.md
+++ b/articles/two-integer-sum.md
@@ -106,6 +106,21 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        for i in 0..<nums.count {
+            for j in (i + 1)..<nums.count {
+                if nums[i] + nums[j] == target {
+                    return [i, j]
+                }
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -313,6 +328,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        var A = [(Int, Int)]()
+        for (i, num) in nums.enumerated() {
+            A.append((num, i))
+        }
+
+        A.sort { $0.0 < $1.0 }
+        var i = 0
+        var j = nums.count - 1
+
+        while i < j {
+            let cur = A[i].0 + A[j].0
+            if cur == target {
+                return [min(A[i].1, A[j].1), 
+                        max(A[i].1, A[j].1)]
+            } else if cur < target {
+                i += 1
+            } else {
+                j -= 1
+            }
+        }
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -469,6 +512,27 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        var indices = [Int: Int]() // val -> index
+
+        for (i, n) in nums.enumerated() {
+            indices[n] = i
+        }
+
+        for (i, n) in nums.enumerated() {
+            let diff = target - n
+            if let j = indices[diff], j != i {
+                return [i, j]
+            }
+        }
+
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -607,6 +671,24 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        var prevMap = [Int: Int]() // val -> index
+
+        for (i, n) in nums.enumerated() {
+            let diff = target - n
+            if let index = prevMap[diff] {
+                return [index, i]
+            }
+            prevMap[n] = i
+        }
+
+        return []
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/valid-binary-search-tree.md b/articles/valid-binary-search-tree.md
index fd885ddfc..3b076e3c7 100644
--- a/articles/valid-binary-search-tree.md
+++ b/articles/valid-binary-search-tree.md
@@ -316,6 +316,44 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isValidBST(_ root: TreeNode?) -> Bool {
+        guard let root = root else { return true }
+        if !isValid(root.left, root.val, { $0 < $1 }) || 
+           !isValid(root.right, root.val, { $0 > $1 }) {
+            return false
+        }
+
+        return isValidBST(root.left) && isValidBST(root.right)
+    }
+
+    private func isValid(_ root: TreeNode?, _ limit: Int, _ check: (Int, Int) -> Bool) -> Bool {
+        guard let root = root else { return true }
+        if !check(root.val, limit) {
+            return false
+        }
+
+        return isValid(root.left, limit, check) && isValid(root.right, limit, check)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -550,6 +588,37 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isValidBST(_ root: TreeNode?) -> Bool {
+        return valid(root, Int.min, Int.max)
+    }
+
+    private func valid(_ node: TreeNode?, _ left: Int, _ right: Int) -> Bool {
+        guard let node = node else { return true }
+        if !(left < node.val && node.val < right) {
+            return false
+        }
+        return valid(node.left, left, node.val) && valid(node.right, node.val, right)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -858,6 +927,48 @@ class Solution {
 }
 ```
 
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func isValidBST(_ root: TreeNode?) -> Bool {
+        guard let root = root else { return true }
+
+        var q = Deque<(TreeNode, Int, Int)>()
+        q.append((root, Int.min, Int.max))
+
+        while !q.isEmpty {
+            let (node, left, right) = q.popFirst()!
+
+            if !(left < node.val && node.val < right) {
+                return false
+            }
+
+            if let leftNode = node.left {
+                q.append((leftNode, left, node.val))
+            }
+            if let rightNode = node.right {
+                q.append((rightNode, node.val, right))
+            }
+        }
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/valid-parenthesis-string.md b/articles/valid-parenthesis-string.md
index 84c0422d8..c412ad605 100644
--- a/articles/valid-parenthesis-string.md
+++ b/articles/valid-parenthesis-string.md
@@ -148,7 +148,52 @@ func checkValidString(s string) bool {
 ```
 
 ```kotlin
+class Solution {
+    fun checkValidString(s: String): Boolean {
+
+        fun dfs(i: Int, open: Int): Boolean {
+            if (open < 0) {
+                return false
+            }
+            if (i == s.length) {
+                return open == 0
+            }
+            
+            return when (s[i]) {
+                '(' -> dfs(i + 1, open + 1)
+                ')' -> dfs(i + 1, open - 1)
+                else -> dfs(i + 1, open) || dfs(i + 1, open + 1) || dfs(i + 1, open - 1)
+            }
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
+```swift
+class Solution {
+    func checkValidString(_ s: String) -> Bool {
+        let chars = Array(s)
+
+        func dfs(_ i: Int, _ open: Int) -> Bool {
+            if open < 0 { return false }
+            if i == chars.count { return open == 0 }
+
+            if chars[i] == "(" {
+                return dfs(i + 1, open + 1)
+            } else if chars[i] == ")" {
+                return dfs(i + 1, open - 1)
+            } else {
+                return dfs(i + 1, open) ||
+                       dfs(i + 1, open + 1) ||
+                       dfs(i + 1, open - 1)
+            }
+        }
 
+        return dfs(0, 0)
+    }
+}
 ```
 
 ::tabs-end
@@ -397,6 +442,47 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkValidString(_ s: String) -> Bool {
+        let n = s.count
+        let sArr = Array(s)
+        var memo = Array(
+            repeating: Array<Bool?>(repeating: nil, count: n + 1),
+            count: n + 1
+        )
+
+        func dfs(_ i: Int, _ open: Int) -> Bool {
+            if open < 0 {
+                return false
+            }
+            if i == n {
+                return open == 0
+            }
+            if let memoized = memo[i][open] {
+                return memoized
+            }
+
+            let result: Bool
+            if sArr[i] == "(" {
+                result = dfs(i + 1, open + 1)
+            } else if sArr[i] == ")" {
+                result = dfs(i + 1, open - 1)
+            } else {
+                result = dfs(i + 1, open) ||
+                         dfs(i + 1, open + 1) ||
+                         dfs(i + 1, open - 1)
+            }
+
+            memo[i][open] = result
+            return result
+        }
+
+        return dfs(0, 0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -620,6 +706,40 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkValidString(_ s: String) -> Bool {
+        let n = s.count
+        var dp = Array(repeating: Array(repeating: false, count: n + 1), count: n + 1)
+        dp[n][0] = true
+
+        let chars = Array(s)
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            for open in 0..<n {
+                var res = false
+                if chars[i] == "*" {
+                    res = res || dp[i + 1][open + 1]
+                    if open > 0 {
+                        res = res || dp[i + 1][open - 1]
+                    }
+                    res = res || dp[i + 1][open]
+                } else {
+                    if chars[i] == "(" {
+                        res = res || dp[i + 1][open + 1]
+                    } else if open > 0 {
+                        res = res || dp[i + 1][open - 1]
+                    }
+                }
+                dp[i][open] = res
+            }
+        }
+
+        return dp[0][0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -815,6 +935,34 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkValidString(_ s: String) -> Bool {
+        let n = s.count
+        var dp = Array(repeating: false, count: n + 1)
+        dp[0] = true
+
+        let chars = Array(s)
+
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            var new_dp = Array(repeating: false, count: n + 1)
+            for open in 0..<n {
+                if chars[i] == "*" {
+                    new_dp[open] = dp[open + 1] || (open > 0 && dp[open - 1]) || dp[open]
+                } else if chars[i] == "(" {
+                    new_dp[open] = dp[open + 1]
+                } else if open > 0 {
+                    new_dp[open] = dp[open - 1]
+                }
+            }
+            dp = new_dp
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1034,6 +1182,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkValidString(_ s: String) -> Bool {
+        var left = [Int]()
+        var star = [Int]()
+
+        let chars = Array(s)
+
+        for (i, ch) in chars.enumerated() {
+            if ch == "(" {
+                left.append(i)
+            } else if ch == "*" {
+                star.append(i)
+            } else {
+                if left.isEmpty && star.isEmpty {
+                    return false
+                }
+                if !left.isEmpty {
+                    left.popLast()
+                } else {
+                    star.popLast()
+                }
+            }
+        }
+
+        while !left.isEmpty && !star.isEmpty {
+            if left.last! > star.last! {
+                return false
+            }
+            left.popLast()
+            star.popLast()
+        }
+
+        return left.isEmpty
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1236,6 +1422,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func checkValidString(_ s: String) -> Bool {
+        var leftMin = 0
+        var leftMax = 0
+
+        for c in s {
+            if c == "(" {
+                leftMin += 1
+                leftMax += 1
+            } else if c == ")" {
+                leftMin -= 1
+                leftMax -= 1
+            } else {
+                leftMin -= 1
+                leftMax += 1
+            }
+            if leftMax < 0 {
+                return false
+            }
+            if leftMin < 0 {
+                leftMin = 0
+            }
+        }
+        return leftMin == 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/valid-sudoku.md b/articles/valid-sudoku.md
index 14c8dc735..74fb5deda 100644
--- a/articles/valid-sudoku.md
+++ b/articles/valid-sudoku.md
@@ -284,6 +284,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isValidSudoku(_ board: [[Character]]) -> Bool {
+        for row in 0..<9 {
+            var seen = Set<Character>()
+            for i in 0..<9 {
+                if board[row][i] == "." { continue }
+                if seen.contains(board[row][i]) { return false }
+                seen.insert(board[row][i])
+            }
+        }
+
+        for col in 0..<9 {
+            var seen = Set<Character>()
+            for i in 0..<9 {
+                if board[i][col] == "." { continue }
+                if seen.contains(board[i][col]) { return false }
+                seen.insert(board[i][col])
+            }
+        }
+
+        for square in 0..<9 {
+            var seen = Set<Character>()
+            for i in 0..<3 {
+                for j in 0..<3 {
+                    let row = (square / 3) * 3 + i
+                    let col = (square % 3) * 3 + j
+                    if board[row][col] == "." { continue }
+                    if seen.contains(board[row][col]) { return false }
+                    seen.insert(board[row][col])
+                }
+            }
+        }
+        
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -510,6 +549,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isValidSudoku(_ board: [[Character]]) -> Bool {
+        var cols = [Int: Set<Character>]()
+        var rows = [Int: Set<Character>]()
+        var squares = [String: Set<Character>]()
+
+        for r in 0..<9 {
+            for c in 0..<9 {
+                if board[r][c] == "." { continue }
+
+                let squareKey = "\(r / 3),\(c / 3)"
+
+                if rows[r]?.contains(board[r][c]) == true ||
+                   cols[c]?.contains(board[r][c]) == true ||
+                   squares[squareKey]?.contains(board[r][c]) == true {
+                    return false
+                }
+
+                rows[r, default: []].insert(board[r][c])
+                cols[c, default: []].insert(board[r][c])
+                squares[squareKey, default: []].insert(board[r][c])
+            }
+        }
+        
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -725,6 +794,35 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isValidSudoku(_ board: [[Character]]) -> Bool {
+        var rows = [Int](repeating: 0, count: 9)
+        var cols = [Int](repeating: 0, count: 9)
+        var squares = [Int](repeating: 0, count: 9)
+
+        for r in 0..<9 {
+            for c in 0..<9 {
+                if board[r][c] == "." { continue }
+                
+                let val = Int(board[r][c].asciiValue! - Character("0").asciiValue!)
+                let bitmask = 1 << (val - 1)
+
+                if (rows[r] & bitmask) != 0 { return false }
+                if (cols[c] & bitmask) != 0 { return false }
+                if (squares[(r / 3) * 3 + (c / 3)] & bitmask) != 0 { return false }
+
+                rows[r] |= bitmask
+                cols[c] |= bitmask
+                squares[(r / 3) * 3 + (c / 3)] |= bitmask
+            }
+        }
+
+        return true
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/valid-tree.md b/articles/valid-tree.md
index a343b676e..7266d9836 100644
--- a/articles/valid-tree.md
+++ b/articles/valid-tree.md
@@ -266,6 +266,44 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func validTree(_ n: Int, _ edges: [[Int]]) -> Bool {
+        if edges.count > (n - 1) {
+            return false
+        }
+        
+        var adj = Array(repeating: [Int](), count: n)
+        for edge in edges {
+            let u = edge[0]
+            let v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+        }
+        
+        var visited = Set<Int>()
+        
+        func dfs(_ node: Int, _ parent: Int) -> Bool {
+            if visited.contains(node) {
+                return false
+            }
+            visited.insert(node)
+            for nei in adj[node] {
+                if nei == parent {
+                    continue
+                }
+                if !dfs(nei, node) {
+                    return false
+                }
+            }
+            return true
+        }
+        
+        return dfs(0, -1) && visited.count == n
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -537,6 +575,45 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func validTree(_ n: Int, _ edges: [[Int]]) -> Bool {
+        if edges.count > n - 1 {
+            return false
+        }
+        
+        var adj = [[Int]](repeating: [], count: n)
+        for edge in edges {
+            let u = edge[0]
+            let v = edge[1]
+            adj[u].append(v)
+            adj[v].append(u)
+        }
+        
+        var visit = Set<Int>()
+        var q = Deque<(Int, Int)>()  // (current node, parent node)
+        q.append((0, -1))
+        visit.insert(0)
+        
+        while !q.isEmpty {
+            let (node, parent) = q.removeFirst()
+            for nei in adj[node] {
+                if nei == parent {
+                    continue
+                }
+                if visit.contains(nei) {
+                    return false
+                }
+                visit.insert(nei)
+                q.append((nei, node))
+            }
+        }
+        
+        return visit.count == n
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -593,7 +670,7 @@ class Solution:
 ```
 
 ```java
-public class DSU {
+class DSU {
     int[] Parent, Size;
     int comps;
 
@@ -932,6 +1009,65 @@ class Solution {
 }
 ```
 
+```swift
+class DSU {
+    var comps: Int
+    var parent: [Int]
+    var size: [Int]
+    
+    init(_ n: Int) {
+        comps = n
+        parent = Array(0..<n)
+        size = Array(repeating: 1, count: n)
+    }
+    
+    func find(_ node: Int) -> Int {
+        if parent[node] != node {
+            parent[node] = find(parent[node])
+        }
+        return parent[node]
+    }
+    
+    func union(_ u: Int, _ v: Int) -> Bool {
+        let pu = find(u)
+        let pv = find(v)
+        if pu == pv {
+            return false
+        }
+        comps -= 1
+        if size[pu] < size[pv] {
+            parent[pu] = pv
+            size[pv] += size[pu]
+        } else {
+            parent[pv] = pu
+            size[pu] += size[pv]
+        }
+        return true
+    }
+    
+    func components() -> Int {
+        return comps
+    }
+}
+
+class Solution {
+    func validTree(_ n: Int, _ edges: [[Int]]) -> Bool {
+        if edges.count > n - 1 {
+            return false
+        }
+        
+        let dsu = DSU(n)
+        for edge in edges {
+            let u = edge[0], v = edge[1]
+            if !dsu.union(u, v) {
+                return false
+            }
+        }
+        return dsu.components() == 1
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/validate-parentheses.md b/articles/validate-parentheses.md
index fc97eac24..a7e649a78 100644
--- a/articles/validate-parentheses.md
+++ b/articles/validate-parentheses.md
@@ -105,6 +105,20 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isValid(_ s: String) -> Bool {
+        var str = s
+        while str.contains("()") || str.contains("{}") || str.contains("[]") {
+            str = str.replacingOccurrences(of: "()", with: "")
+            str = str.replacingOccurrences(of: "{}", with: "")
+            str = str.replacingOccurrences(of: "[]", with: "")
+        }
+        return str.isEmpty
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -291,6 +305,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func isValid(_ s: String) -> Bool {
+        var stack = [Character]()
+        let closeToOpen: [Character: Character] = [")": "(", "]": "[", "}": "{"]
+
+        for c in s {
+            if let open = closeToOpen[c] {
+                if !stack.isEmpty && stack.last! == open {
+                    stack.popLast()
+                } else {
+                    return false
+                }
+            } else {
+                stack.append(c)
+            }
+        }
+        
+        return stack.isEmpty
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/word-break.md b/articles/word-break.md
index 908708670..acc8366d3 100644
--- a/articles/word-break.md
+++ b/articles/word-break.md
@@ -176,6 +176,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        let chars = Array(s)
+
+        func dfs(_ i: Int) -> Bool {
+            if i == chars.count {
+                return true
+            }
+            
+            for w in wordDict {
+                if i + w.count <= chars.count, 
+                   String(chars[i..<i + w.count]) == w {
+                    if dfs(i + w.count) {
+                        return true
+                    }
+                }
+            }
+            return false
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -363,6 +389,32 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        let wordSet = Set(wordDict)
+        let chars = Array(s)
+
+        func dfs(_ i: Int) -> Bool {
+            if i == chars.count {
+                return true
+            }
+
+            for j in i..<chars.count {
+                if wordSet.contains(String(chars[i...j])) {
+                    if dfs(j + 1) {
+                        return true
+                    }
+                }
+            }
+            return false
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -585,6 +637,36 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        var memo = [Int: Bool]()
+        memo[s.count] = true
+        let chars = Array(s)
+
+        func dfs(_ i: Int) -> Bool {
+            if let cached = memo[i] {
+                return cached
+            }
+
+            for w in wordDict {
+                if i + w.count <= chars.count, 
+                   String(chars[i..<i + w.count]) == w {
+                    if dfs(i + w.count) {
+                        memo[i] = true
+                        return true
+                    }
+                }
+            }
+            memo[i] = false
+            return false
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -851,6 +933,42 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        let wordSet = Set(wordDict)
+        var maxLen = 0
+        for w in wordDict {
+            maxLen = max(maxLen, w.count)
+        }
+
+        var memo = [Int: Bool]()
+        let chars = Array(s)
+
+        func dfs(_ i: Int) -> Bool {
+            if let cached = memo[i] {
+                return cached
+            }
+            if i == chars.count {
+                return true
+            }
+            for j in i..<min(chars.count, i + maxLen) {
+                if wordSet.contains(String(chars[i...j])) {
+                    if dfs(j + 1) {
+                        memo[i] = true
+                        return true
+                    }
+                }
+            }
+            memo[i] = false
+            return false
+        }
+
+        return dfs(0)
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1021,6 +1139,29 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        var dp = Array(repeating: false, count: s.count + 1)
+        dp[s.count] = true
+        let chars = Array(s)
+
+        for i in stride(from: s.count - 1, through: 0, by: -1) {
+            for w in wordDict {
+                if i + w.count <= chars.count, String(chars[i..<i + w.count]) == w {
+                    dp[i] = dp[i + w.count]
+                }
+                if dp[i] {
+                    break
+                }
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1086,7 +1227,7 @@ class Solution:
 ```
 
 ```java
-public class TrieNode {
+class TrieNode {
     HashMap<Character, TrieNode> children;
     boolean isWord;
 
@@ -1096,7 +1237,7 @@ public class TrieNode {
     }
 }
 
-public class Trie {
+class Trie {
     TrieNode root;
 
     public Trie() {
@@ -1497,6 +1638,70 @@ class Solution {
 }
 ```
 
+```swift
+class TrieNode {
+    var children = [Character: TrieNode]()
+    var isWord = false
+}
+
+class Trie {
+    private let root = TrieNode()
+
+    func insert(_ word: String) {
+        var node = root
+        for char in word {
+            if node.children[char] == nil {
+                node.children[char] = TrieNode()
+            }
+            node = node.children[char]!
+        }
+        node.isWord = true
+    }
+
+    func search(_ s: [Character], _ i: Int, _ j: Int) -> Bool {
+        var node = root
+        for idx in i...j {
+            if node.children[s[idx]] == nil {
+                return false
+            }
+            node = node.children[s[idx]]!
+        }
+        return node.isWord
+    }
+}
+
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        let trie = Trie()
+        for word in wordDict {
+            trie.insert(word)
+        }
+
+        var dp = Array(repeating: false, count: s.count + 1)
+        dp[s.count] = true
+        let chars = Array(s)
+
+        var maxLen = 0
+        for word in wordDict {
+            maxLen = max(maxLen, word.count)
+        }
+
+        for i in stride(from: s.count, through: 0, by: -1) {
+            for j in i..<min(s.count, i + maxLen) {
+                if trie.search(chars, i, j) {
+                    dp[i] = dp[j + 1]
+                    if dp[i] {
+                        break
+                    }
+                }
+            }
+        }
+
+        return dp[0]
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/word-ladder.md b/articles/word-ladder.md
index 2bc3893bf..ea29ccf35 100644
--- a/articles/word-ladder.md
+++ b/articles/word-ladder.md
@@ -492,6 +492,84 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
+        if !wordList.contains(endWord) || beginWord == endWord {
+            return 0
+        }
+        
+        let n = wordList.count
+        let m = wordList[0].count
+        var adj = [[Int]](repeating: [], count: n)
+        var mp = [String: Int]()
+        
+        for i in 0..<n {
+            mp[wordList[i]] = i
+        }
+        
+        let wordArrays = wordList.map { Array($0) }
+        
+        for i in 0..<n {
+            for j in (i + 1)..<n {
+                var cnt = 0
+                let arr1 = wordArrays[i]
+                let arr2 = wordArrays[j]
+                for k in 0..<m {
+                    if arr1[k] != arr2[k] {
+                        cnt += 1
+                    }
+                }
+                if cnt == 1 {
+                    adj[i].append(j)
+                    adj[j].append(i)
+                }
+            }
+        }
+        
+        var q = Deque<Int>()
+        var res = 1
+        var visit = Set<Int>()
+        let beginChars = Array(beginWord)
+        
+        for i in 0..<m {
+            for c in 97...122 {
+                let ch = Character(UnicodeScalar(c)!)
+                if ch == beginChars[i] {
+                    continue
+                }
+                let prefix = String(beginChars[0..<i])
+                let suffix = i + 1 < beginChars.count ? String(beginChars[(i + 1)...]) : ""
+                let word = prefix + String(ch) + suffix
+                if let idx = mp[word], !visit.contains(idx) {
+                    q.append(idx)
+                    visit.insert(idx)
+                }
+            }
+        }
+        
+        while !q.isEmpty {
+            res += 1
+            let levelCount = q.count
+            for _ in 0..<levelCount {
+                let node = q.removeFirst()
+                if wordList[node] == endWord {
+                    return res
+                }
+                for nei in adj[node] {
+                    if !visit.contains(nei) {
+                        visit.insert(nei)
+                        q.append(nei)
+                    }
+                }
+            }
+        }
+        
+        return 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -767,6 +845,49 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
+        if !wordList.contains(endWord) || beginWord == endWord {
+            return 0
+        }
+
+        var words = Set(wordList)
+        var queue = Deque<String>()
+        queue.append(beginWord)
+        var res = 0
+
+        while !queue.isEmpty {
+            res += 1
+            for _ in 0..<queue.count {
+                let node = queue.popFirst()!
+                if node == endWord {
+                    return res
+                }
+                let nodeArray = Array(node)
+                for i in 0..<nodeArray.count {
+                    for c in 97...122 {
+                        let char = Character(UnicodeScalar(c)!)
+                        if char == nodeArray[i] {
+                            continue
+                        }
+                        var neiArray = nodeArray
+                        neiArray[i] = char
+                        let nei = String(neiArray)
+                        if words.contains(nei) {
+                            queue.append(nei)
+                            words.remove(nei)
+                        }
+                    }
+                }
+            }
+        }
+
+        return 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1108,6 +1229,61 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
+        if !wordList.contains(endWord) {
+            return 0
+        }
+
+        var nei = [String: [String]]()
+        var wordList = wordList
+        wordList.append(beginWord)
+
+        for word in wordList {
+            let wordArray = Array(word)
+            for j in 0..<wordArray.count {
+                var patternArray = wordArray
+                patternArray[j] = "*"
+                let pattern = String(patternArray)
+                nei[pattern, default: []].append(word)
+            }
+        }
+
+        var visit: Set<String> = [beginWord]
+        var queue = Deque<String>()
+        queue.append(beginWord)
+        var res = 1
+
+        while !queue.isEmpty {
+            for _ in 0..<queue.count {
+                let word = queue.popFirst()!
+                if word == endWord {
+                    return res
+                }
+                let wordArray = Array(word)
+                for j in 0..<wordArray.count {
+                    var patternArray = wordArray
+                    patternArray[j] = "*"
+                    let pattern = String(patternArray)
+
+                    if let neighbors = nei[pattern] {
+                        for neiWord in neighbors {
+                            if !visit.contains(neiWord) {
+                                visit.insert(neiWord)
+                                queue.append(neiWord)
+                            }
+                        }
+                    }
+                }
+            }
+            res += 1
+        }
+        return 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1482,6 +1658,61 @@ class Solution {
 }
 ```
 
+```swift
+class Solution {
+    func ladderLength(_ beginWord: String, _ endWord: String, _ wordList: [String]) -> Int {
+        if !wordList.contains(endWord) || beginWord == endWord {
+            return 0
+        }
+
+        let m = wordList[0].count
+        var wordSet = Set(wordList)
+        var qb = Deque<String>([beginWord])
+        var qe = Deque<String>([endWord])
+        var fromBegin = [beginWord: 1]
+        var fromEnd = [endWord: 1]
+
+        while !qb.isEmpty && !qe.isEmpty {
+            if qb.count > qe.count {
+                swap(&qb, &qe)
+                swap(&fromBegin, &fromEnd)
+            }
+
+            for _ in 0..<qb.count {
+                let word = qb.popFirst()!
+                let steps = fromBegin[word]!
+
+                var wordArray = Array(word)
+                for i in 0..<m {
+                    let originalChar = wordArray[i]
+                    for c in 97...122 {
+                        let char = Character(UnicodeScalar(c)!)
+                        if char == originalChar {
+                            continue
+                        }
+                        wordArray[i] = char
+                        let nei = String(wordArray)
+
+                        if !wordSet.contains(nei) {
+                            continue
+                        }
+                        if let endSteps = fromEnd[nei] {
+                            return steps + endSteps
+                        }
+                        if fromBegin[nei] == nil {
+                            fromBegin[nei] = steps + 1
+                            qb.append(nei)
+                        }
+                    }
+                    wordArray[i] = originalChar
+                }
+            }
+        }
+        return 0
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity