백준 1927

문제

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

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

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

입력

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

출력

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

예제 입력 1

9
0
12345678
1
2
0
0
0
0
32

예제 출력 1

0
1
2
12345678
0

풀이1(kotlin)

 - 최소 힙은 우선순위 큐를 위해 만들어진 자료구조이다. 따라서 우선순위 큐를 이용하여 풀이하였다.

import java.util.PriorityQueue

private val w = System.out.bufferedWriter()
private val r = System.`in`.bufferedReader()

fun main() {
    val N = r.readLine().toInt()
    val pQ = PriorityQueue<Int>()
    repeat(N) {
        val n = r.readLine().toInt()
        when(n) {
            0 -> {
                if (pQ.isEmpty()) w.write("0\n")
                else w.write("${pQ.poll()}\n")
            }
            else -> {
                pQ.add(n)
            }
        }
    }
    w.close()
}

풀이2(kotlin)

 - 최소 힙(Min Heap)을 직접 구현할 수도 있다.

private val w = System.out.bufferedWriter()
private val r = System.`in`.bufferedReader()

fun main() {
    val n = r.readLine().toInt()
    val heap = MinHeap(n + 1)
    repeat(n) {
        val input = r. readLine().toInt()
        if (input == 0) {
            w.write("${heap.remove()}\n")
        } else {
            heap.add(input)
        }
    }

    w.close()
}

class MinHeap(initialSize: Int) {
    private val array = IntArray(initialSize)
    private var size = 0

    fun add(v: Int) {
        val i = ++size
        array[i] = v
        siftUp(i, v)
    }

    fun remove(): Int {
        if (size == 0) {
            return 0
        }

        val ret = array[1]
        array[1] = array[size]
        array[size] = 0
        size -= 1
        siftDown(1, array[1])
        return ret
    }

    private fun siftUp(i: Int, v: Int) {
        var index = i
        while (index > 1) {
            val parent = index shr 1
            if (array[parent] > v) {
                array[index] = array[parent]
                array[parent] = v
            }
            index = parent
        }
    }

    private fun siftDown(i: Int, v: Int) {
        var index = i
        val lastNotLeafIndex = size shr 1

        while (index <= lastNotLeafIndex) {
            var lessChildIndex = index * 2
            if (array[lessChildIndex + 1] != 0 && array[lessChildIndex + 1] < array[lessChildIndex]) {
                lessChildIndex += 1
            }

            if (array[lessChildIndex] < v) {
                array[index] = array[lessChildIndex]
                array[lessChildIndex] = v
            } else {
                return
            }

            index = lessChildIndex
        }

    }
}