Swift Library

[Algorithm] LeetCode - Search in Rotated Sorted Array

Swift librarian — Mon, 19 May 2025 18:02:54 +0900

문제

Search in Rotated Sorted Array
난이도 Medium
정렬되었지만 n칸 밀린 Array에서 target값이 존재하는지 확인하는 문제 (시간복잡도 log n 제한)

Example 1:
	Input: nums = [4,5,6,7,0,1,2], target = 0
	Output: 4

Example 2:
	Input: nums = [4,5,6,7,0,1,2], target = 3
	Output: -1

풀이

시간복잡도가 log n 이기 때문에 이진탐색이 생각났다. 결국 왼쪽을 탐색할지 오른쪽을 탐색해야 할지 결정하는 기준을 세우는 문제이다. 아래까지는 거의 모든 이진탐색이 비슷하게 시작할 것이라 생각된다.

func search(_ nums: [Int], _ target: Int) -> Int {
    var left = 0
    var right = nums.count - 1

    while left < right {
        let mid = (left + right) / 2

문제는 [0,1,2,3,4,5,6,7,8] 처럼 정렬이 잘 되어있으면 찾으면 되는데... [3,4,5,6,7,8,0,1,2] 처럼 몇 칸 밀려있을 때가 문제이다. 그것을 아래와 같이 left가 mid보다 작거나 같다면 왼쪽이 정렬되어 있어 정렬되어 있는 왼쪽부터 검증을 시도하고, 그렇지 않다면 오른쪽이 정렬되어 있다는 뜻이니 오른쪽부터 검증을 시도하였다.

여기서 left가 mid보다 작기만 하면 되는 거 아닌가?라고 할 수도 있지만 left == mid 일 경우이다. left가 3이고 right가 4일 경우라고 해보자 [4,5,6,7,8,0,1,2,3] 일 경우 3, 4 인덱스만 뽑아보면 [8,0]인데 [8]은 정렬되어 있지만 [8, 0]은 정렬되어 있지 않다. 결국 left가 mid와 같다면 nums[left] < nums[mid] 이면 무조건 오른쪽이 정렬이 된다고 판단하기 때문에 보다 작거나 같다는 조건이 필요하다.

        if nums[left] <= nums[mid] { /// 왼쪽이 정렬되어 있음
            if nums[left]...nums[mid] ~= target {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else { /// 오른쪽이 정렬되어 있음
            if nums[mid]...nums[right] ~= target {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }

결과

전체 코드는 아래와 같고 가장 빠른 속도가 나왔다.

func search(_ nums: [Int], _ target: Int) -> Int {
    var left = 0
    var right = nums.count - 1

    while left < right {
        let mid = (left + right) / 2

        if nums[mid] == target { return mid }

        if nums[left] <= nums[mid] { /// 왼쪽이 정렬되어 있음
            if nums[left]...nums[mid] ~= target {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else { /// 오른쪽이 정렬되어 있음
            if nums[mid]...nums[right] ~= target {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }

    return nums[left] == target ? left : -1
}

[Algorithm] LeetCode - Maximum Product Subarray

Swift librarian — Wed, 14 May 2025 13:34:03 +0900

문제

Maximum Product Subarray
난이도 Medium
부분배열중 가장 곱이 높은 배열을 찾는 문제

Input: nums = [-2,0,-1]
Output: 0
Explanation: The result cannot be 2, because [-2,-1] is not a subarray.

풀이

이 문제의 고민은 만약에 부분합이라면 투포인터를 사용할 수 있지만 부분 곱셈에서는 조금 까다로운 문제가 있었다.

배열의 요소 중 하나라도 0이 나왔을 땐 무조건 곱이 0이 되므로 포인터를 움직이며 비교할 수 없다는 것.
음수는 같은 음수를 만나면 오히려 더 높은 숫자가 나올 수 있다는 것.

결국 아래와 같이 maxBuffer, minBuffer를 두어 해결하고자 했다. 또한 0일 경우를 고려해서 아무것도 곱하지 않은 num부터도 가능하게 했다. 이렇게 푸니 O(n)의 시간복잡도로 풀 수 있었다.

func maxProduct(_ nums: [Int]) -> Int {
    var result = nums[0]
    var maxBuffer = 1
    var minBuffer = 1

    for num in nums {
        let candidates = [num, maxBuffer * num, minBuffer * num]
        maxBuffer = candidates.max() ?? 1
        minBuffer = candidates.min() ?? 1
        result = max(result, maxBuffer)
    }

    return result
}

참고로 메모리부분은 이렇게 간단한 문제는 아래와 같이 똑같은 코드를 돌려도 그때그때 격차가 큰 것 같다.

[Algorithm] LeetCode - Remove Nth Node From End of List

Swift librarian — Mon, 12 May 2025 21:49:06 +0900

문제

Remove Nth Node From End of List
난이도: Medium
연결리스트에서 끝에서 n번째의 요소를 제거하는 문제

Input: head = [1,2,3,4,5], n = 2
Output: [1,2,3,5]

풀이

요즘 연결리스트 문제를 자주 푸는 것 같다. 이 문제는 먼저 n번 노드를 뒤로 보낸 후에 같이 이동하면서 next가 nil이면 start.next = start.next.next 로 연결을 끊어주면 된다.

func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
    let zero: ListNode? = ListNode(0)
    zero?.next = head

    var start = zero
    var end = zero

    for _ in 0..<n {
        end = end?.next
    }

    while let next = end?.next {
        start = start?.next
        end = next
    }

    start?.next = start?.next?.next

    return zero?.next
}

Runtime에서 좋은 결과를 얻을 수 있었다.

[Algorithm] LeetCode - Reorder List

Swift librarian — Mon, 12 May 2025 18:11:52 +0900

문제

Reorder List
난이도: Medium
주어진 리스트를 재배열하는 문제이다.

You are given the head of a singly linked-list. The list can be represented as:

L0 → L1 → … → Ln - 1 → Ln
Reorder the list to be on the following form:

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
You may not modify the values in the list's nodes. Only nodes themselves may be changed.

풀이

아래와 같은 조건이 있었기 때문에 기존의 리스트를 가지고 재배열을 해야했다.

You may not modify the values in the list's nodes. Only nodes themselves may be changed.

아래처럼 연결리스트를 반으로 잘라 뒤집어서 번갈아 넣으면 되지 않을까? 생각했다.

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8

1 -> 2 -> 3 -> 4 | 5 <- 6 <- 7 <- 8

1️⃣ 배열 중간 찾기

아래와 같이 한칸, 두칸을 가는 노드를 만들어서 중간지점을 찾았다. O(n)

    var slow: ListNode? = head
    var fast: ListNode? = head

    while fast?.next != nil && fast?.next?.next != nil {
        slow = slow?.next
        fast = fast?.next?.next
    }

2️⃣ 중간부터 시작해서 배열 뒤집기

5 → 6 → 7 → 8 리스트를 5 ← 6 ← 7 ← 8 로 만든다.

    var postNode: ListNode? = nil
    var currentNode: ListNode? = slow?.next
    slow?.next = nil

    while let node = currentNode {
        let next = node.next
        node.next = postNode
        postNode = node
        currentNode = next
    }

3️⃣ 리스트 번갈아가면서 연결하기

1부터 시작, 8부터 시작해서 번갈아가면서 연결한다.

    var first: ListNode? = head
    var second: ListNode? = postNode

    while let node = second {
        let tmp1 = first?.next
        let tmp2 = node.next

        first?.next = second
        node.next = tmp1

        first = tmp1
        second = tmp2
    }

아래의 괜찮은 결과가 나왔다.

func reorderList(_ head: ListNode?) {
    guard let head = head, head.next != nil else { return }

    var slow: ListNode? = head
    var fast: ListNode? = head

    while fast?.next != nil && fast?.next?.next != nil {
        slow = slow?.next
        fast = fast?.next?.next
    }

    var postNode: ListNode? = nil
    var currentNode: ListNode? = slow?.next
    slow?.next = nil

    while let node = currentNode {
        let next = node.next
        node.next = postNode
        postNode = node
        currentNode = next
    }

    var first: ListNode? = head
    var second: ListNode? = postNode

    while let node = second {
        let tmp1 = first?.next
        let tmp2 = node.next

        first?.next = second
        node.next = tmp1

        first = tmp1
        second = tmp2
    }
}

[Algorithm] LeetCode - 3Sum

Swift librarian — Sun, 11 May 2025 22:43:46 +0900

문제

3Sum
난이도: Medium
배열중 3개를 뽑아 더하면 0이 되는 배열을 겹치지 않게 뽑는 문제

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]
Explanation: 
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
The distinct triplets are [-1,0,1] and [-1,-1,2].
Notice that the order of the output and the order of the triplets does not matter.

Brute Force

항상 문제를 보면 단순하게 한번 풀어본다. 아래의 풀이는 단순하게 O(n^3)으로 푸는 방법인데 당연하게도 시간초과가 난다. (nums.length는 최대 3,000이라 단순 연산으로 최대 27,000,000,000번 연산을 하게 될 수 있으니까... )

func threeSum(_ nums: [Int]) -> [[Int]] {
    let nums = nums.sorted()
    var triplets: [[Int]] = []

    for i in 0..<nums.count {
        for j in i+1..<nums.count {
            for k in j+1..<nums.count {
                let triplet = [nums[i], nums[j], nums[k]]
                if triplet.reduce(0, +) == 0 && !triplets.contains(triplet) {
                    triplets.append(triplet)
                }
            }
        }
    }

    return triplets
}

풀이

이문제는 좌표 하나를 기반으로 정렬을 한 후 투포인터 알고리즘을 쓰면 된다. 이렇게 된다면 O(n^2)이다. 살짝 까다로운것이 배열이 중복되면 안되기 때문에 똑같은 숫자로 시작하거나 0이 나왔을 때도 똑같은 숫자를 소거해줘야 한다.

func threeSum(_ nums: [Int]) -> [[Int]] {
    let nums = nums.sorted()
    var triplets: [[Int]] = []

    for i in nums.indices {
        /// 똑같은 숫자면 투포인터를 하지 않는다.
        if i > 0 && nums[i] == nums[i-1] { continue }

        var left = i + 1
        var right = nums.count - 1

        while left < right {
            let sum = nums[i] + nums[left] + nums[right]

            if sum == 0 {
                triplets.append([nums[i], nums[left], nums[right]])
               
                /// 0이 나오면 똑같은 숫자를 건너뛴다.
                while left < right && nums[left] == nums[left + 1] { left += 1 }
                while left < right && nums[right] == nums[right - 1] { right -= 1 }

                left += 1
                right -= 1
            } else if sum < 0 {
                left += 1
            } else {
                right -= 1
            }
        }
    }

    return triplets
}

결과는 아래와 같이 준수한(?) 결과가 나왔다.

[Algorithm] LeetCode - Missing Number

Swift librarian — Sun, 11 May 2025 20:53:55 +0900

문제

Missing Number
난이도: Easy
주어진 0부터 n까지 있는 배열에서 비어있는 숫자를 찾는 문제

Input: nums = [3,0,1]
Output: 2
Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.

풀이

이 문제는 아주 단순하게 풀린다. 모든 수를 더하고 배열을 순회하면서 마이너스하면 결국 없는 숫자가 남게 된다. 한줄로 해결도 가능하다!

func missingNumber(_ nums: [Int]) -> Int {
    nums.reduce((nums.count * (nums.count + 1) / 2), -)
}

[Algorithm] LeetCode - Linked List Cycle

Swift librarian — Fri, 9 May 2025 16:07:42 +0900

문제

Linked List Cycle
난이도: Easy
연결리스트 사이클이 있는지 찾는 문제

Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).

풀이

솔직히 이 문제가 왜 Easy인지 모르겠다. 아래처럼 ListNode 배열이나 ObjectIdentifier 집합을 사용하여 풀면 풀리긴 하지만... 이런 문제를 풀 때 아주아주 유명한 알고리즘이 있다.

func hasCycle(_ head: ListNode?) -> Bool {
    var visited: [ListNode] = []
    var current = head

    while let node = current {
        if visited.contains(where: { $0 === node }) { return true }
        visited.append(node)
        current = node.next
    }

    return false
}

func hasCycle(_ head: ListNode?) -> Bool {
    var visited = Set<ObjectIdentifier>()
    var current = head

    while let node = current {
        let id = ObjectIdentifier(node)
        if visited.contains(id) {
            return true
        }
        visited.insert(id)
        current = node.next
    }

    return false
}

바로 아래처럼 플로이드의 토끼와 거북이 알고리즘을 사용하면 저장하는것이 없기 때문에 훨씬 효율적으로 풀 수 있다. 거북이는 한 칸 이동, 토끼는 두 칸 이동! 사이클의 개수는 홀수 혹은 짝수이기 때문에 언젠간 만난다.

func hasCycle(_ head: ListNode?) -> Bool {
    var   = head
    var   = head

    while let next =  ?.next?.next {
          =  ?.next
          = next

        if   ===   { return true }
    }

    return false
}

아래와 같이 문제와 관련된 유튜버 Joma Tech님의 재미있는 영상도 있다.

[Algorithm] LeetCode - Word Break

Swift librarian — Fri, 9 May 2025 14:58:15 +0900

문제

Word Break
난이도: Medium
단어 사전에 있는 단어 조합으로 주어진 문자열을 모두 대체할 수 있는지 찾는 문제

Input: s = "leetcode", wordDict = ["leet","code"]
Output: true
Explanation: Return true because "leetcode" can be segmented as "leet code".

시행착오

아래와 같이 풀면 되지 않을까? 생각했다. 앞에서부터 순회하지 않는 이유는 word, words 같은 두 개의 문자가 있을 때 words를 대체해야 하기 때문에 앞에서부터 하면 word를 하고 s가 남지 않을까? 해서였다.

func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
    var words = Set(wordDict)
    var buffer = ""

    for chr in s.reversed() {
        buffer = String(chr) + buffer

        if words.contains(buffer) {
            buffer = ""
        }
    }

    return buffer.isEmpty
}

하지만 이 풀이는 s = "aaaaaaa" wordDick = ["aaa", "aaaa"] 일때 바로 실패했다. ☠️ 왜냐하면 결국 a가 남기 때문에...!

풀이

결국 이 문제는 dp로 풀게 되었다. 이전의 검증된 배열에서 추가로 단어를 더해가는 것이기 때문에 아래와 같이 dp배열을 만들어 준 뒤, 해당 길이까지 true라면 그때 이후로 단어가 들어가 있는지를 확인하는 방식이다.

func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
    var words = Set(wordDict)
    var chrs = Array(s)
    
    var dp = Array(repeating: false, count: s.count + 1)
    dp[0] = true

    for i in 1...s.count {
        for j in 0..<i {
            let word = String(chrs[j..<i])

            if dp[j] && words.contains(word) {
                dp[i] = true
                break
            }
        }
    }

    return dp[s.count]
}

살짝 아쉬운 결과가 나왔다. 뭔가 놓친 게 있는 걸까?

개선된 풀이

모든 단어의 개수보다는 사전에 있는 단어 개수로만 판단하면 되지 않을까라는 생각에 아래와 같이 wordCounts배열을 만든 뒤 이 안에 있는 값만 활용했다. 물론 longestWordCount만 찾아서 판별하는 방법도 있긴 하지만 아래의 방식이 좀 더 이해가 되는 느낌이 들어 아래와 같이 작성했다.

물론 여기서 sorted(by: >)로 긴 단어부터 체크하면 시간이 조금 더 빨라졌지만 그건 테스트케이스에 따라 그리고 LeetCode는 빌드할 때마다 근소한 차이가 보이기 때문에 큰 의미가 없다고 생각했다. 오히려 sorted를 해주면 O(n)이 O(nlogn)으로 늘어나기 때문에 좋지 않다고 판단했다.

func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
    var words = Set(wordDict)
    var wordCounts = words.map { $0.count }
    var chrs = Array(s)
    
    var dp = Array(repeating: false, count: s.count + 1)
    dp[0] = true

    for end in 1...s.count {
        for wordCount in wordCounts {
            let start = max(end - wordCount, 0)

            let word = String(chrs[start..<end])

            if dp[start] && words.contains(word) {
                dp[end] = true
                break
            }
        }
    }

    return dp[s.count]
}

9ms로 만족할 만한 결과가 나왔다. 돌릴 때마다 2~3ms는 편차가 있는 듯하다.

[Algorithm] LeetCode - Container With Most Water

Swift librarian — Thu, 8 May 2025 18:32:55 +0900

문제

Container With Most Water
난이도: Medium
주어진 배열에서 양 끝점으로 한 가장 큰 직사각형의 넓이를 구하는 문제

Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49
Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.

풀이

첫 번째로 가장 무식하게 모든 경우의 수를 체크하는 방법이 있다. 물론 n의 입력값이 10^5이기 때문에 시간초과!

func maxArea(_ height: [Int]) -> Int {
    let count = height.count
    var result = 0
    
    for start in 0..<count {
        for end in (start..<count) {
            let area = (end - start) * min(height[start], height[end])
            result = max(result, area)
        }
    }

    return result
}

어떻게 효율적으로 접근할 수 있을까? 이 문제가 정말 재밌었던 게 조금만 생각해 보면 쉬운 방법이 나온다. 조건 하나만 추가해 주면 문제가 풀린다.

바로바로 아래의 조건 한줄을 루프에 추가해 주면 된다. 그 이유는 만약에 양끝에서 시작해서 height[start]가 height[end]보다 적다면 종료해 주면 된다. 그때가 바로 최대일 수밖에 없다. start의 높이는 고정이 되어있기 때문에 height[start]의 높이를 사용해서 넓이를 쟀을 때가 최대이다.

if height[start] < height[end] { break }

최종 코드는 아래와 같다.

func maxArea(_ height: [Int]) -> Int {
    let count = height.count
    var result = 0
    
    for start in 0..<count {
        for end in (start..<count).reversed() {
            let area = (end - start) * min(height[start], height[end])
            result = max(result, area)
            if height[start] < height[end] { break }
        }
    }

    return result
}

풀이 개선

하지만 아쉬웠던 건 92ms로 풀긴 했지만 Beats 5.19%... 그리고 위의 풀이는 결국 O(n^2)의 시간복잡도이다. 결국 이것보다 훨씬 효율적인 방법이 있다는 뜻이다. 바로바로 투포인터 알고리즘! left, right부터 시작해서 높이가 더 높은곳으로 나아가는 방식으로 코드를 작성하면 O(n)의 시간복잡도로 풀 수 있다.

func maxArea(_ height: [Int]) -> Int {
    var left = 0
    var right = height.count - 1
    var result = 0

    while left < right {
        let area = (right - left) * min(height[left], height[right])
        result = max(result, area)

        if height[left] < height[right] {
            left += 1
        } else {
            right -= 1
        }
    }

    return result
}

오케이... 3ms로 약 30배 빠르게 개선했다. 하지만 내앞에 계신 60%분들도 제치고 싶다...!

O(n)보다 개선하는 것은 조건을 추가해주지 않는 이상 불가능하다. 우선 불필요한 연산을 줄이고자 max함수를 쓰지 않고 아래와 같이 코드를 작성했더니 바로 개선이 되었다.

func maxArea(_ height: [Int]) -> Int {
    var left = 0
    var right = height.count - 1
    var result = 0

    while left < right {
        let area = (right - left) * min(height[left], height[right])
        if area > result { result = area } // max 함수를 쓰지 않음

        if height[left] < height[right] {
            left += 1
        } else {
            right -= 1
        }
    }

    return result
}

0ms... 굳... 계산상 ♾️배 개선했다.

[Algorithm] LeetCode - Clone Graph

Swift librarian — Wed, 7 May 2025 13:23:25 +0900

문제

Clone Graph
난이도: Medium
주어진 그래프를 깊은 복사하는 문제이다.

class Node {
    public int val;
    public List<Node> neighbors;
}

Input: adjList = [[2,4],[1,3],[2,4],[1,3]]
Output: [[2,4],[1,3],[2,4],[1,3]]

풀이

어어...? 이 문제를 풀면서 살짝 당황했다. 당연히 쉽게 생각했던 깊은 복사가 생각보다 쉽지 않구나라는 것을 알게 되었다. 왜냐하면 새로운 객체를 생성하면서 연결된 객체들을 다시 연결해줘야 하기 때문에 이것이 생각보다 까다롭다.

문제에서 가지고 있는 val을 key로 사용하고 새롭게 인스턴스를 만들면 된다. 만약 val이 없다면 Swift는 ObjectIdentifier를 활용하면 된다. 나는 mapped라는 딕셔너리를 활용하여 객체에 바로 접근하고 그 객체에 연결된 객체를 새로운 객체를 만들어서 연결해주었다. 연결된 객체를 방문하는 방식은 BFS를 사용했다.

class Solution {
    func cloneGraph(_ node: Node?) -> Node? {
        guard let node else { return nil }
        
        let copied = Node(node.val)
        var mapped: [Int: Node] = [node.val: copied]

        var queue = [node]
        var i = 0

        while queue.count > i {
            let popped = queue[i]
            let neighbors = popped.neighbors.compactMap { $0 }

            neighbors.forEach { node in
                let value = node.val
                
                if mapped[value] == nil {
                    mapped[value] = Node(value)
                    queue.append(node)
                }

                mapped[popped.val]?.neighbors.append(mapped[value])
            }

            i += 1
        }

        return copied
    }
}

결과는 아래와 같았다.