27-alstjr7437 #198

alstjr7437 · 2024-05-26T13:14:51Z

🔗 문제 링크

이중 우선순위 큐

아니 생각해보니 문제 이름부터 알고리즘 스포인데요?

✔️ 소요된 시간

1시간 30분

알고리즘

우선순위 큐

❌ 틀린 수도 코드

heap으로 만든다.
push는 일반적인 방법으로 진행한다.
pop일 경우 1이면 heap에서 heappop으로 제일 작은 부분을 빼준다
pop일 경우 -1이면 List에서 pop()으로 제일 큰 부분을 빼준다.

하지만 Heap.pop()을 하게 되면 heap 시간복잡도가 O(1)은 맞지만 힙 구조를 유지하지 못합니다!!

그런데 이상하게 시간 초과가 뜨던데 왜그러는지 아실까여...?

from heapq import *

t = int(input())
for _ in range(t):
    heap = []
    q = int(input())

    for _ in range(q):
        k = list(input().split())
        if k[0] == "I" :
            heappush(heap, int(k[1]))
        else :
            if len(heap) == 0:
                continue
            if int(k[1]) == -1:
                heappop(heap)
            else :
                heap.pop()

    if len(heap) == 0 :
        print("EMPTY")
    else :
        print(heap[-1], heap[0])

🅾️ 정답 수도 코드

우선적으로 개념을 이해하기 위해서 max랑 min heap을 만들어야 한다는건 알았습니다!!
➡️ Python에서는 최소 Heap만 지원을 해서!!!

최소 힙 (Min-Heap): 기본 힙, 최소값 저장
최대 힙 (Max-Heap): 요소 음수 저장, 최대값 저장

하지만 위와 같이 minheap, maxheap을 만들어서
min값이 없어지면 Max도 없어져야 하는 동기화가 필요했습니다.

이부분에서 많이 막혀서 인터넷에 참고하니 어떤 사람은 딕셔너리로 만들고
어떤 사람은 배열을 미리 만들어두고 사용하는 방식을 사용했습니다.

처음에는 딕셔너리를 이용하려 했지만 막히는 부분이 많아서
q로 받는 명령어의 개수 만큼 nums라는 동기화를 위한 배열을 선언해줬습니다!!!

그래서 만든 코드가

heap에 추가하는 부분

min_heap은 기본 heap이 최소 힙이므로 그대로 삽입해주고 뒤에 동기화를 위한 i라는 Index를 넣어줬습니다.
max_heap에 -를 붙여줘야 제일 큰 수가 빠지므로 -iNum을 넣어줬습니다.

if k[0] == "I" :
    heappush(min_heap, (iNum,i))    # 동기화를 위한 i도 튜플로 넣어주기
    heappush(max_heap, (-iNum, i))
    nums[i] = True

⭐️⭐️⭐️ 삭제 로직

처음 heap 구조

1	2	3	4	5
10	20	30	40	50

들어오는 명령어 D -1(최소), D 1(최대), D -1(최소)

최소 힙

1	2	3	4	5	명령어
False	20	30	40	50	D -1
False	20	30	40	50(False)	D 1
False	False	30	40	50(False)	D -1

-> 30이 남게 됨 최소 힙에

최대 힙

1	2	3	4	5	명령어
-50	-40	-30	-20	-10(False)	D -1
False	-40	-30	-20	-10(False)	D 1
False	-40	-30	-20(False)	-10(False)	D -1
False	-40	-30	-20(False)	-10(False)	최종

-> 최대 힙에 40이 남게 됨

heap에 최대값 삭제하는 부분 - D 1

while문은 max_heap이 남아있고,
maxheap의 앞부분(예에서는 50)이 이미 버려져 있으면 pop으로 버려버리기 -> 동기화를 위해서

if 문은
max_heap에서 작은수 제거 -> 최대 힙으로 제일 큰 수 버리기

elif iNum == 1:
    while max_heap and not nums[max_heap[0][1]]:   
        heappop(max_heap)
    if max_heap:     # max_heap에서 작은 수 제거
        nums[max_heap[0][1]] = False 
        heappop(max_heap)

heap에 최소값 삭제하는 부분 - D -1

위의 최대힙과 같은 로직으로 돌아감

else:
    while min_heap and not nums[min_heap[0][1]]:    # 이미 삭제된 노드인 경우 삭제되지 않은 노드 나올때까지 모두 버림
        heappop(min_heap)
    if min_heap:    # min_heap에서 작은 수(삭제 노드) 제거
        nums[min_heap[0][1]] = False
        heappop(min_heap)

모든 연산 후 동기화 되지 않은 노드 처리

위의 삭제 로직과 똑같이 min, max heap의 앞부분을 확인하고 동기화되어 있지 않으면
노드들을 삭제함

while min_heap and not nums[min_heap[0][1]]:
    heappop(min_heap)
while max_heap and not nums[max_heap[0][1]]:
    heappop(max_heap)

⭐️⭐️⭐️ 동기화의 중요성

처음 heap 구조

1	2	3	4
10	20	30	40

들어오는 명령어 D -1(최소), D -1(최소), D 1(최대), D 1(최대)

최소 힙

1	2	3	4	명령어
False	15	20	30	D -1
False	False	20	30	D -1
False	False	20(False)	30	D 1
False	False	20(False)	30(False)	D 1
		20(False)	30(False)	최종
				동기화 후

동기화 while 문 처리 ➡️ heap[0][1]이 False면 pop을 해버림 ➡️ 2개 다 빠짐
Empty가 됨!!!

최소 힙

1	2	3	4	명령어
-30	-20	-15	-10(False)	D -1
-30	-20	-15(False)	-10(False)	D -1
False	-20	-15(False)	-10(False)	D 1
False	False	-15(False)	-10(False)	D 1
		-15(False)	-10(False)	최종
				동기화 후

�최대 힙과 같은 방식

💡 최종 코드

from heapq import *
import sys

input = sys.stdin.readline

t = int(input())

for _ in range(t):
    q = int(input())

    # 최소힙만 지원해서 최대, 최소 만들어주기
    min_heap = []
    max_heap = []
    nums = [False] * q  # 동기화를 위한 부분

    for i in range(q):
        k = list(input().split())
        iNum = int(k[1])  

        # 입력 부분
        if k[0] == "I" :
            heappush(min_heap, (iNum,i))    # 동기화를 위한 i도 튜플로 넣어주기
            heappush(max_heap, (-iNum, i))
            nums[i] = True
        elif iNum == 1:
            while max_heap and not nums[max_heap[0][1]]:   
                heappop(max_heap)
            if max_heap:     # max_heap에서 작은 수 제거
                nums[max_heap[0][1]] = False 
                heappop(max_heap)
        else:
            while min_heap and not nums[min_heap[0][1]]:    # 이미 삭제된 노드인 경우 삭제되지 않은 노드 나올때까지 모두 버림
                heappop(min_heap)
            if min_heap:    # min_heap에서 작은 수(삭제 노드) 제거
                nums[min_heap[0][1]] = False
                heappop(min_heap)
        # print(min_heap, max_heap, nums, k)
    # 모든 연산 후 동기화 되지 않은 노드 처리
    while min_heap and not nums[min_heap[0][1]]:
        heappop(min_heap)
    while max_heap and not nums[max_heap[0][1]]:
        heappop(max_heap)

    if max_heap and min_heap :
        print(-max_heap[0][0], min_heap[0][0])
    else :
        print("EMPTY")

📚 새롭게 알게된 내용

python에서 heap은 최소힙만 지원을 하게 되는 사실을 알곤 있었지만 체감하니 참 어렵더군요...

그래도 visited 형태로 두고 두개의 힙을 동기화 하면서 푸는 방법이 재밌었습니다!!

tgyuuAn

from heapq import *

t = int(input())
for _ in range(t):
    heap = []
    q = int(input())

    for _ in range(q):
        k = list(input().split())
        if k[0] == "I" :
            heappush(heap, int(k[1]))
        else :
            if len(heap) == 0:
                continue
            if int(k[1]) == -1:
                heappop(heap)
            else :
                heap.pop()

    if len(heap) == 0 :
        print("EMPTY")
    else :
        print(heap[-1], heap[0])

이 로직에서 시간 초과가 나는 이유는 모르겠씁니다...

하지만 저기서 최대 값을 빼려고 heap.pop()을 하신거는 힙 자료구조를 완벽히 이해하지 못하고 사용한 것 같습니다!!

지금은 저 로직이 왜 잘못되었는 지 아시겠죠 ...?!

시간초과가 아니더라도 틀렸습니다로 출력되었을 것 같습니다.

저도 이거 여러가지 수가 들어왔을 때의 동기화를 생각해서 처음에는 집합으로 접근했다가,

2개 이상의 수가 들어오고 하나의 수가 빠졌을 때 집합으로 저장되면 그냥 남아있는 수도 없는 수 취급하고 제거되기 때문에 딕셔너리로 바꿔서 제출했더니 solved 되었습니다!

from heapq import *
from collections import defaultdict
import sys

def input(): return sys.stdin.readline().rstrip()

T = int(input())
for _ in range(T):
    K = int(input())
    min_heap = []
    max_heap = []
    elements = defaultdict(int)

    for _ in range(K):
        query = input()
        method, value = query.split()

        if method == "I":
            heappush(min_heap, int(value))
            heappush(max_heap, -1*int(value))
            elements[int(value)] += 1

        elif method == "D":
            if len(elements) == 0: continue

            # 최소값
            if value =="-1":
                while min_heap[0] not in elements:
                    heappop(min_heap)
                    
                popped = heappop(min_heap)
                elements[popped] -= 1
                if elements[popped] == 0: del elements[popped]

            # 최대값
            elif value =="1":
                while -1*max_heap[0] not in elements:
                    heappop(max_heap)
                    
                popped = heappop(max_heap)
                elements[-1*popped] -= 1
                if elements[-1*popped] == 0: del elements[-1*popped]

    if len(elements) == 0: print("EMPTY")
    else:
        remain = sorted(list(elements))
        print(remain[-1], remain[0])

힙 자료구조를 공부할 때 유용하겠네요.... 재미있어요.

특히 파이썬으로 우선순위 큐를 공부할 때 엄청 유용한 문제 같아요.

적어주신 것처럼 파이썬에서 최대 값 우선순위 큐를 사용하기 위해서는 저런 잡 기술을 사용해야하는데,

상당히 자주쓰이기 때문이에요!

고생하셨씁니둥~~ 👍🏻👍🏻

SeongHoonC

정말 상세한 PR... 너무 감사합니다!!
저는 맵(딕셔너리)으로 저장해서 관리했습니다...!
poll 한 값의 count 가 0 이하이면 (이미 다 빠졌으면) 다시 poll 하고를 반복해서 동기화시켜줬습니다!

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.Collections
import java.util.PriorityQueue

lateinit var br: BufferedReader
fun main() {
    br = BufferedReader(InputStreamReader(System.`in`))
    val T = br.readLine().toInt()

    repeat(T) {
        program()
    }
}

private fun program() {
    val pqMin = PriorityQueue<Int>()
    val pqMax = PriorityQueue<Int>(Collections.reverseOrder())

    val k = br.readLine().toInt()
    val store = mutableMapOf<Int, Int>()

    for (i in 0 until k) {
        val input = br.readLine().split(" ")
        val instruction = input[0]
        val n = input[1].toInt()

        if (instruction == "I") {
            pqMin.add(n)
            pqMax.add(n)
            store[n] = store.getOrPut(n) { 0 } + 1
            continue
        }
        if (n == -1) {
            delete(pqMin, store)
        } else {
            delete(pqMax, store)
        }
    }
    var max = pqMax.poll()
    var min = pqMin.poll()

    if (max == null || min == null) {
        println("EMPTY")
        return
    }

    while (store[max]!! <= 0) {
        max = pqMax.poll()
        if (max == null) {
            println("EMPTY")
            return
        }
    }

    while (store[min]!! <= 0) {
        min = pqMin.poll()
        if (min == null) {
            println("EMPTY")
            return
        }
    }
    println("$max $min")
}

private fun delete(pq: PriorityQueue<Int>, store: MutableMap<Int, Int>) {
    val target: Int = pq.poll() ?: return
 
   if (store[target]!! <= 0) {
        delete(pq, store)
        return
    }
    store[target] = store[target]!! - 1
}

H0ngJu

자세한 PR 감사합니다 ~~

저도 일단 1트는 시간 초과 나왔습니다..

1트에서는 D 1이 나올 떄마다 최대힙으로 바꿔준 후 pop하고, 다시 최소힙으로 바꿔주는 과정을 넣었습니다.

1 try

import sys
import heapq

def input(): return sys.stdin.readline().rstrip()

T = int(input())

def transform_heap(h):
    return [-x for x in h]

for t in range(T):
    k = int(input())
    heap = []

    command = [input().split() for _ in range(k)]
    for i in range(k):
        if command[i][0] == "I":
            heapq.heappush(heap, int(command[i][1]))
        elif command[i][0] == "D" and int(command[i][1]) == 1:
            if len(heap) > 0:
                heap = transform_heap(heap) # 최대 힙으로 바꿔줌
                heapq.heapify(heap)

                heapq.heappop(heap)
                heap = transform_heap(heap) # 최소 힙으로 되돌리기

                heapq.heapify(heap)
            else: continue
        elif command[i][0] == "D" and int(command[i][1]) == -1:
            if len(heap) > 0:
                heapq.heappop(heap)

            else: continue
        else:
            print("error") # 확인용
    
    if len(heap) > 0:
        print(heap[0], heap[len(heap)-1])
    else:
        print("EMPTY")

D 1이 나올 때마다 최대힙으로 바꿔줘서 시간초과가 난 것 같아요 해당 부분이 O(n)이라서?

그래서 일단 최소 힙으로는 최대값을 pop할 수 없겠다 싶어서
처음부터 최대 힙, 최소 힙으로 두고 둘이 공통인 부분만 최종적으로 list에 담아주면 되겠다 !
라고 생각했숨다

입력할 떄마다 min_heap와 max_heap에 push.
D -1 이면 min_heap에서 pop
D 1 이면 max_heap에서 pop
min_heap과 max_heap에 공통적으로 있는 것만 골라서 heap에 저장하고 출력

그렇게 2트 했는데 답이 안나오더라고요. 동기화 로직이 잘못된 것 같아요 🫠

2 try

import sys
import heapq

def input(): return sys.stdin.readline().rstrip()

T = int(input())

def transform_heap(h):
    return [-x for x in h]

for t in range(T):
    k = int(input())
    heap = []

    max_heap = []
    min_heap = []

    command = [input().split() for _ in range(k)]
    for i in range(k):
        if command[i][0] == "I":
            heapq.heappush(max_heap, -int(command[i][1]))
            heapq.heappush(min_heap, int(command[i][1]))
        elif command[i][0] == "D" and int(command[i][1]) == 1:
            if len(max_heap) > 0:
                heapq.heappop(max_heap)
            else: continue
        elif command[i][0] == "D" and int(command[i][1]) == -1:
            if len(min_heap) > 0:
                heapq.heappop(min_heap)
            else: continue
        else:
            print("error") # 확인용
    
    max_len = max(len(max_heap), len(min_heap))

    if len(max_heap) == max_len:
        for i in max_heap:
            if -i in min_heap:
                heap.append(-i)
    else:
        for i in min_heap:
            if -i in max_heap:
                print("here", i)
                heap.append(i)

    if len(heap) > 0:
        print(heap[0], heap[len(heap)-1])
    else:
        print("EMPTY")

이제 어떻게 해야할지 생각이 안나서 민석님 PR 참고했습니다..
따로 True, False를 저장할 list를 만들어 줘야 하는군용 .. 배워갑니다 ... 👍
덕분에 heap 복습하고 갑니둥

alstjr7437 · 2024-05-29T07:27:37Z

자세한 PR 감사합니다 ~~

저도 일단 1트는 시간 초과 나왔습니다..

1트에서는 D 1이 나올 떄마다 최대힙으로 바꿔준 후 pop하고, 다시 최소힙으로 바꿔주는 과정을 넣었습니다.

1 try
D 1이 나올 때마다 최대힙으로 바꿔줘서 시간초과가 난 것 같아요 해당 부분이 O(n)이라서?

그래서 일단 최소 힙으로는 최대값을 pop할 수 없겠다 싶어서 처음부터 최대 힙, 최소 힙으로 두고 둘이 공통인 부분만 최종적으로 list에 담아주면 되겠다 ! 라고 생각했숨다

입력할 떄마다 min_heap와 max_heap에 push.

D -1 이면 min_heap에서 pop

D 1 이면 max_heap에서 pop

min_heap과 max_heap에 공통적으로 있는 것만 골라서 heap에 저장하고 출력

그렇게 2트 했는데 답이 안나오더라고요. 동기화 로직이 잘못된 것 같아요 🫠

2 try
import sys
import heapq

def input(): return sys.stdin.readline().rstrip()

T = int(input())

def transform_heap(h):
    return [-x for x in h]

for t in range(T):
    k = int(input())
    heap = []

    max_heap = []
    min_heap = []

    command = [input().split() for _ in range(k)]
    for i in range(k):
        if command[i][0] == "I":
            heapq.heappush(max_heap, -int(command[i][1]))
            heapq.heappush(min_heap, int(command[i][1]))
        elif command[i][0] == "D" and int(command[i][1]) == 1:
            if len(max_heap) > 0:
                heapq.heappop(max_heap)
            else: continue
        elif command[i][0] == "D" and int(command[i][1]) == -1:
            if len(min_heap) > 0:
                heapq.heappop(min_heap)
            else: continue
        else:
            print("error") # 확인용
    
    max_len = max(len(max_heap), len(min_heap))

    if len(max_heap) == max_len:
        for i in max_heap:
            if -i in min_heap:
                heap.append(-i)
    else:
        for i in min_heap:
            if -i in max_heap:
                print("here", i)
                heap.append(i)

    if len(heap) > 0:
        print(heap[0], heap[len(heap)-1])
    else:
        print("EMPTY")
이제 어떻게 해야할지 생각이 안나서 민석님 PR 참고했습니다.. 따로 True, False를 저장할 list를 만들어 줘야 하는군용 .. 배워갑니다 ... 👍 덕분에 heap 복습하고 갑니둥

오호 2번째 방법 신기하네요!!
2번째 방법은 따로 시간초과가 난걸까요?

27차시 문제 선정

13e2521

alstjr7437 added 작성 중 ⏱️ alstjr7437 labels May 26, 2024

alstjr7437 self-assigned this May 26, 2024

27차시 solved

1154ee3

alstjr7437 added 리뷰 기다리는 중 🔥 and removed 작성 중 ⏱️ labels May 27, 2024

github-actions bot requested review from H0ngJu, SeongHoonC and tgyuuAn May 27, 2024 07:00

tgyuuAn approved these changes May 27, 2024

View reviewed changes

SeongHoonC approved these changes May 27, 2024

View reviewed changes

H0ngJu approved these changes May 27, 2024

View reviewed changes

tgyuuAn added 리뷰 완료 ✔️ and removed 리뷰 기다리는 중 🔥 labels May 27, 2024

alstjr7437 merged commit 191e484 into main May 29, 2024
10 checks passed

alstjr7437 deleted the 27-alstjr7437 branch May 29, 2024 07:27

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

27-alstjr7437 #198

27-alstjr7437 #198

alstjr7437 commented May 26, 2024 •

edited

Loading

tgyuuAn left a comment

SeongHoonC left a comment

H0ngJu left a comment •

edited

Loading

alstjr7437 commented May 29, 2024

27-alstjr7437 #198

27-alstjr7437 #198

Conversation

alstjr7437 commented May 26, 2024 • edited Loading

🔗 문제 링크

✔️ 소요된 시간

알고리즘

❌ 틀린 수도 코드

🅾️ 정답 수도 코드

heap에 추가하는 부분

⭐️⭐️⭐️ 삭제 로직

처음 heap 구조

최소 힙

최대 힙

heap에 최대값 삭제하는 부분 - D 1

heap에 최소값 삭제하는 부분 - D -1

모든 연산 후 동기화 되지 않은 노드 처리

⭐️⭐️⭐️ 동기화의 중요성

처음 heap 구조

최소 힙

최소 힙

💡 최종 코드

📚 새롭게 알게된 내용

tgyuuAn left a comment

Choose a reason for hiding this comment

SeongHoonC left a comment

Choose a reason for hiding this comment

H0ngJu left a comment • edited Loading

Choose a reason for hiding this comment

alstjr7437 commented May 29, 2024

alstjr7437 commented May 26, 2024 •

edited

Loading

H0ngJu left a comment •

edited

Loading