๐ ๋ฌธ์
https://programmers.co.kr/learn/courses/30/lessons/42628
๋ฌธ์ ์ค๋ช
์ด์ค ์ฐ์ ์์ ํ๋ ๋ค์ ์ฐ์ฐ์ ํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํฉ๋๋ค.
๋ช ๋ น์ด์์ ํ(๋์ด)
I ์ซ์ | ํ์ ์ฃผ์ด์ง ์ซ์๋ฅผ ์ฝ์ ํฉ๋๋ค. |
D 1 | ํ์์ ์ต๋๊ฐ์ ์ญ์ ํฉ๋๋ค. |
D -1 | ํ์์ ์ต์๊ฐ์ ์ญ์ ํฉ๋๋ค. |
์ด์ค ์ฐ์ ์์ ํ๊ฐ ํ ์ฐ์ฐ operations๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฐ์ฐ์ ์ฒ๋ฆฌํ ํ ํ๊ฐ ๋น์ด์์ผ๋ฉด [0,0] ๋น์ด์์ง ์์ผ๋ฉด [์ต๋๊ฐ, ์ต์๊ฐ]์ return ํ๋๋ก solution ํจ์๋ฅผ ๊ตฌํํด์ฃผ์ธ์.
์ ํ์ฌํญ
- operations๋ ๊ธธ์ด๊ฐ 1 ์ด์ 1,000,000 ์ดํ์ธ ๋ฌธ์์ด ๋ฐฐ์ด์ ๋๋ค.
- operations์ ์์๋ ํ๊ฐ ์ํํ ์ฐ์ฐ์ ๋ํ๋
๋๋ค.
- ์์๋ “๋ช ๋ น์ด ๋ฐ์ดํฐ” ํ์์ผ๋ก ์ฃผ์ด์ง๋๋ค.- ์ต๋๊ฐ/์ต์๊ฐ์ ์ญ์ ํ๋ ์ฐ์ฐ์์ ์ต๋๊ฐ/์ต์๊ฐ์ด ๋ ์ด์์ธ ๊ฒฝ์ฐ, ํ๋๋ง ์ญ์ ํฉ๋๋ค.
- ๋น ํ์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ผ๋ ์ฐ์ฐ์ด ์ฃผ์ด์ง ๊ฒฝ์ฐ, ํด๋น ์ฐ์ฐ์ ๋ฌด์ํฉ๋๋ค.
โ๏ธ ํ์ด
ํ์ด์ฌ์ heapq๋ ์ต์ํ์ ๊ธฐ์ค์ผ๋ก ์ด๋ค์ง๋ค๊ณ ํ๊ธฐ์, ์ต๋ํ์ ๊ฒฝ์ฐ์๋ ๋ง์ด๋์ค๋ฅผ ๋ถ์ฌ์ ์ด์ฉํ๋ค.
ex) 1,3,5์ ๋ง์ด๋์ค๋ฅผ ๋ถ์ฌ์ ์ต์ํ์ ๋ฃ์ด์ฃผ๋ฉด ์ต๋ํ์ฒ๋ผ -5,-3,-1์ผ๋ก ์ ๋ ฌ๋๋ค.
โป๏ธ ์คํผ๋ ์ด์ ์ ๋ง๊ฒ ๊ฐ์ ๋ฃ๊ฑฐ๋ ๋บ๋ค.
โป๏ธ ํ ๋ ๊ฐ๋ ์ต๋/์ต์๊ฐ์ ๋นจ๋ฆฌ ์ฐพ๊ธฐ ์ํด ์ด์ฉํ๋ ๊ฒ์ผ ๋ฟ, ๊ฐ์ด ๋ค์ด๊ฐ๊ณ ๋น ์ง๋๊ฑด ๋๊ฐ์ด ์ผ์ด๋์ผ ํ๋ค.
โป๏ธ ์ต๋๊ฐ์ ๋นผ๋ฉด max_heap์์, ์ต์๊ฐ์ ๋นผ๋ฉด min_heap์์ ๊ฐ์ ๊บผ๋ธ ํ์ ๋จ์ ๋ค๋ฅธ ํ์์๋ ํด๋น ๊ฐ์ ๋๊ฐ์ด ๋นผ์ค๋ค.
โป๏ธ ๋ชจ๋ ์ฐ์ฐ์ด ๋๋๋ฉด max_heap์์ ํ๋, min_heap์์ ํ๋๋ฅผ ๊บผ๋ด์ด ์ต๋/์ต์๊ฐ์ผ๋ก ๋ฆฌํดํด์ค๋ค.
๐โ๏ธ ์๊ฒฌ
์ต๋ํ/์ต์ํ์ ๋ ๋ค ๋๊ณ ์ฐ๋๊ฒ ์ข์ ์ฝ๋์ธ์ง๋ ๋ชจ๋ฅด๊ฒ ์ง๋ง.....ํต๊ณผํ์ผ๋ ์ฌ๋ ค๋ณธ๋ค.
๐ป ์์ค์ฝ๋: ํ์ด์ฌ(Python)
import heapq
def solution(operations):
min_heap = []
max_heap = []
for op in operations:
o, n = op.split()
if o=="I":
# heappush: O(logN)
heapq.heappush(min_heap, int(n))
heapq.heappush(max_heap, -int(n))
if len(min_heap)!=0:
# heappop: O(logN)
# heapify: O(N)
if o=="D" and n=="1":
max = -heapq.heappop(max_heap)
min_heap.remove(max)
heapq.heapify(min_heap)
elif o=="D" and n=="-1":
min = heapq.heappop(min_heap)
max_heap.remove(-min)
heapq.heapify(max_heap)
if len(max_heap)==0:
return [0,0]
return [-heapq.heappop(max_heap), heapq.heappop(min_heap)]
#์์
operations = ["I 7","I 5","I -5","D -1"]
#์ถ๋ ฅ
print(solution(operations))
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ