[백준(BOJ)] 1927 최소 힙 - 스위프트(Swift)

[Silver II] 최소 힙 - 1927

문제 링크

성능 요약

메모리: 81080 KB, 시간: 124 ms

분류

자료 구조, 우선순위 큐

문제 설명

널리 잘 알려진 자료구조 중 최소 힙이 있다. 최소 힙을 이용하여 다음과 같은 연산을 지원하는 프로그램을 작성하시오.

1. 배열에 자연수 x를 넣는다.
2. 배열에서 가장 작은 값을 출력하고, 그 값을 배열에서 제거한다.

프로그램은 처음에 비어있는 배열에서 시작하게 된다.

입력

첫째 줄에 연산의 개수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 x가 주어진다. 만약 x가 자연수라면 배열에 x라는 값을 넣는(추가하는) 연산이고, x가 0이라면 배열에서 가장 작은 값을 출력하고 그 값을 배열에서 제거하는 경우이다. x는 2³¹보다 작은 자연수 또는 0이고, 음의 정수는 입력으로 주어지지 않는다.

출력

입력에서 0이 주어진 횟수만큼 답을 출력한다. 만약 배열이 비어 있는 경우인데 가장 작은 값을 출력하라고 한 경우에는 0을 출력하면 된다.

 

풀이

사실 해당 문제는 최소 힙을 구현하면 풀리는 문제이기 때문에, 최소 힙을 만드는 것이 관건이었습니다.

 

힙을 생성하는 것은 아직 저도 외우고있지 않아서,, 식을 참고하였습니다.

 

다음은 코드입니다.

import Foundation

// 최소 힙 생성
var minHeap = Heap<Int>()

// 입력 처리
let n = Int(readLine()!)!

for _ in 0..<n {
    let x = Int(readLine()!)!
    
    if x == 0 {
        // 힙에서 가장 작은 값 출력하고 제거
        if let min = minHeap.pop() {
            print(min)
        } else {
            print(0)
        }
    } else {
        // 힙에 값 추가
        minHeap.insert(x)
    }
}

// 최소 힙 구현
struct Heap<Element: Comparable> {
    private var elements: [Element] = []

    mutating func insert(_ value: Element) {
        elements.append(value)
        swim(elements.count - 1)
    }

    mutating func pop() -> Element? {
        guard !elements.isEmpty else {
            return nil
        }
        elements.swapAt(0, elements.count - 1)
        let poppedValue = elements.removeLast()
        sink(0)
        return poppedValue
    }

    private mutating func swim(_ index: Int) {
        var index = index
        while index > 0 {
            let parentIndex = (index - 1) / 2
            if elements[index] < elements[parentIndex] {
                elements.swapAt(index, parentIndex)
                index = parentIndex
            } else {
                break
            }
        }
    }

    private mutating func sink(_ index: Int) {
        var index = index
        while true {
            let leftChildIndex = index * 2 + 1
            let rightChildIndex = index * 2 + 2
            var smallestIndex = index

            if leftChildIndex < elements.count && elements[leftChildIndex] < elements[smallestIndex] {
                smallestIndex = leftChildIndex
            }
            if rightChildIndex < elements.count && elements[rightChildIndex] < elements[smallestIndex] {
                smallestIndex = rightChildIndex
            }

            if smallestIndex == index {
                break
            }

            elements.swapAt(index, smallestIndex)
            index = smallestIndex
        }
    }
}