[BOJ] 백준 11286 절댓값 힙

백준 11286번 절댓값 힙 (실버 1)

문제

절댓값 힙은 다음과 같은 연산을 지원하는 자료구조이다.

1. 배열에 정수 x (x ≠ 0)를 넣는다.
2. 배열에서 절댓값이 가장 작은 값을 출력하고, 그 값을 배열에서 제거한다. 절댓값이 가장 작은 값이 여러개일 때는, 가장 작은 수를 출력하고, 그 값을 배열에서 제거한다.

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

입력
첫째 줄에 연산의 개수 N(1≤N≤100,000)이 주어진다. 다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 x가 주어진다. 만약 x가 0이 아니라면 배열에 x라는 값을 넣는(추가하는) 연산이고, x가 0이라면 배열에서 절댓값이 가장 작은 값을 출력하고 그 값을 배열에서 제거하는 경우이다. 입력되는 정수는 $-2^{31}$보다 크고, $2^{31}$보다 작다.

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

문제 풀이

파이썬의 우선순위 큐 문제는 heapq, PriorityQueue 두 가지 라이브러리를 사용할 수 있다.
해당 문제는 heapq 라이브러리를 사용했다.

우선 힙 자료구조를 알아보자.

힙 자료구조

heapq 모듈은 이진 트리(binary tree) 기반의 최소 힙(min heap) 자료구조를 제공한다.

min heap을 사용하면 원소들이 항상 정렬된 상태로 추가되고 삭제되며, min heap에서 가장 작은값은 언제나 인덱스 0, 즉, 이진 트리의 루트에 위치한다.
내부적으로 min heap 내의 모든 원소(k)는 항상 자식 원소들(2k+1, 2k+2) 보다 크기가 작거나 같도록 원소가 추가되고 삭제된다.
heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2]

예를 들어, 아래 그림은 위 공식을 만족시키는 간단한 min heap의 구조이다.

     1  ---> root
   /   \
  3     5
 / \   /
4   8 7

최소 힙 생성
heapq 모듈은 파이썬의 리스트를 마치 최소 힙처럼 다룰 수 있도록 도와준다.
그렇게 때문에, 그냥 빈 리스트를 생성해놓은 다음 heapq 모듈의 함수를 호출할 때 마다 이 리스트를 인자로 넘겨야 한다.
다시말해, 파이썬에서는 heapq 모듈을 통해서 원소를 추가하거나 삭제한 리스트가 그냥 최소 힙이다.

힙에 원소 추가
heapq 모듈의 heappush() 함수를 이용하여 힙에 원소를 추가할 수 있다. 첫번째 인자는 원소를 추가할 대상 리스트이며 두번째 인자는 추가할 원소다.

from heapq import heappush

heap = []
heappush(heap, 4)
heappush(heap, 1)
heappush(heap, 7)
heappush(heap, 3)
print(heap)

> [1, 3, 7, 4]

가장 작은 1이 인덱스 0에 위치하며, 인덱스 1(= k)에 위치한 3은 인덱스 3(= 2k + 1)에 위치한 4보다 크므로 힙의 공식을 만족한다. 내부적으로 이진 트리에 원소를 추가하는 heappush() 함수는 $O(log(n))$의 시간 복잡도를 가지게 된다.

힙에서 원소 삭제
heapq 모듈의 heappop() 함수를 이용하여 힙에서 원소를 삭제할 수 있다. 원소를 삭제할 대상 리스트를 인자로 넘기면, 가장 작은 원소를 삭제 후에 그 값을 리턴한다.

from heapq import heappop

print(heappop(heap)) # 1
print(heap) # [3, 4, 7]

가장 작았던 1이 삭제되어 리턴되었고, 그 다음으로 작었던 3이 인덱스 0으로 올라온다.

print(heappop(heap)) # 3
print(heap) # [4, 7]

가장 작었던 3이 삭제되어 리턴되었고, 그 다음으로 작았던 4가 인덱스 0으로 올라온다. 내부적으로 이진 트리로 부터 원소를 삭제하는 heappop() 함수 역시 $O(log(n))$의 시간 복잡도를 가지게 된다.

최소값 삭제하지 않고 얻기
힙에서 최소값을 삭제하지 않고 단순히 읽기만 하려면 일반적으로 리스트의 첫번째 원소에 접근하듯이 인덱스를 통해 접근하면 된다.

print(heap[0]) # 4

여기서 주의사항은 인덱스 0에 가장 작은 원소가 있다고 해서, 인덱스 1에 두번째 작은 원소, 인덱스 2에 세번째 작은 원소가 있다는 보장은 없다는 것이다.
왜냐하면 힙은 heappop() 함수를 호출하여 원소를 삭제할 때마다 이진 트리의 재배치를 통해 매번 새로운 최소값을 인덱스 0에 위치시키기 때문.

따라서 두번째로 작은 원소를 얻으려면 바로 heap[1]으로 접근하면 안 되고, 반드시 heappop()을 통해 가장 작은 원소를 삭제 후에 heap[0]를 통해 새로운 최소값에 접근해야한다.

기존 리스트를 힙으로 변환
이미 원소가 들어있는 리스트 힙으로 만들려면 heapq 모듈의 heapify()라는 함수에 사용하자.

from heapq import heapify

heap = [4, 1, 7, 3, 8, 5]
heapify(heap)
print(heap) # [1, 3, 5, 4, 8, 7]

heapify() 함수에 리스트를 인자로 넘기면 리스트 내부의 원소들의 위에서 다룬 힙 구조에 맞게 재배치되며 최소값이 0번째 인덱스에 위치된다.
heapify() 함수의 성능은 인자로 넘기는 리스트의 원소수에 비례한다. 즉 $O(n)$의 시간 복잡도를 가지게 된다.

heapify() 함수를 사용할 때 주의할 점은 새로운 리스트를 반환하는 것이 아니라 인자로 넘긴 리스트를 직접 변경한다는 것이다.

최대 힙
heapq 모듈은 최소 힙(min heap)을 기능만을 동작하기 때문에 최대 힙(max heap)으로 활용하려면 약간의 요령이 필요하다.
바로 힙에 튜플(tuple)를 원소로 추가하거나 삭제하면, 튜플 내에서 맨 앞에 있는 값을 기준으로 최소 힙이 구성되는 원리를 이용하는 것이다.

따라서, 최대 힙을 만들려면 각 값에 대한 우선 순위를 구한 후, (우선 순위, 값) 구조의 튜플(tuple)을 힙에 추가하거나 삭제하면 된다.
그리고 힙에서 값을 읽어올 때는 각 튜플에서 인덱스 1에 있는 값을 취하면 된다. (우선 순위에는 관심이 없으므로 )

from heapq import heappush, heappop

nums = [4, 1, 7, 3, 8, 5]
heap = []

for num in nums:
  heappush(heap, (-num, num))  # (우선 순위, 값)

while heap:
  print(heappop(heap)[1], end = " ")  # index 1
  
> 8 7 5 4 3 1

그렇다면 절대값은 어떻게 해야 할까?

절대값 힙

문제에서 요구한 바는 다음과 같다.

1. 배열에 정수 x (x ≠ 0)를 넣는다.
2. 배열에서 절댓값이 가장 작은 값을 출력하고, 그 값을 배열에서 제거한다. 절댓값이 가장 작은 값이 여러개일 때는, 가장 작은 수를 출력하고, 그 값을 배열에서 제거한다.

절대값이 가장 작은 값을 출력한다 -> 이 부분은 쉽다. 왜냐하면 위에서 최대 힙을 만든 것 처럼 튜플로 (절대값, 값) 을 넣어주면 되기 때문이다.

우리가 신경써야 할 부분은 "절댓값이 가장 작은 값이 여러개일 때는, 가장 작은 수를 출력" 부분이다.

즉, 절대값을 기준으로 정렬 시키는데, 절대값이 같으면 값이 작은 수를 출력해야 한다.

이는 생각보다 간단하다. 그냥 위에서 언급한 대로 (절대값, 값)을 인자로 넣어주면 된다.

어떻게 가능할까?

heapq 모듈은 원소들이 무슨 타입이든 내부적으로 < 비교 연산자를 사용하고, int, string, tuple, list 등 자주 쓰이는 타입들에 대하여 < 연산자의 의미가 각각 정의되어 있기 때문에 그 정의대로 동작한다.

즉, 파이썬에서 튜플 2개를 비교할 때는 왼쪽부터 같은 위치의 원소끼리 서로 비교하다가 먼저 끝나거나 더 작은 원소가 나오는 쪽이 작다.

따라서 abs(x)가 같다면, 그 다음 위치의 원소끼리 자동으로 비교한다는 것이다.

예를 들면, -2와 2가 있다고 치자.
우리는 (abs(-2), -2) 와 (abs(2), 2)를 heapq를 이용하여 최소힙으로 정렬할 것이다.
첫 인자인 절댓값 부분은 각각 2로 같으니, 다음 위치의 인자인 -2와 2를 비교해서 더 작은 -2가 부모 노드에 오게 된다는 것이다.

import sys
import heapq

n = int(sys.stdin.readline())
heap = []
for _ in range(n):
    x = int(sys.stdin.readline())
    if x != 0:
        heapq.heappush(heap, (abs(x), x))
    else:
        if heap:
            print(heapq.heappop(heap)[1])
        else:
            print(0)

참고 : https://www.daleseo.com/python-heapq/