def kthLargest(nums, k):
h = []
for num in nums:
heapq.heappush(h, num)
if len(h) > k:
heapq.heapop()
return h[0]
def addNum(self, num):
if not self.max_heap or num > -self.max_heap[0]:
heapq.heappush(self.min_heap, num)
if len(self.min_heap) > len(self.max_heap) + 1:
heapq.heappush(self.max_heap, -heapq.heapop(self.min_heap))
else:
heapq.heappush(self.max_heap, -num)
if len(self.max_heap) > len(self.min_heap):
heapq.heappush(self.min_heap, -heapq.heapop(self.max_heap))
def addNum(self, num):
"""
:type num: int
:rtype: void
"""
if not self.max_heap or num > -self.max_heap[0]:
heapq.heappush(self.min_heap, num)
if len(self.min_heap) > len(self.max_heap) + 1:
heapq.heappush(self.max_heap, -heapq.heapop(self.min_heap))
else:
heapq.heappush(self.max_heap, -num)
if len(self.max_heap) > len(self.min_heap):
heapq.heappush(self.min_heap, -heapq.heapop(self.max_heap))
def build_tree(frequencies):
nodes = []
for char, frequency in frequencies.items():
heapq.heappush(nodes, (frequency, Node(char)))
while len(nodes) > 1:
f1, n1 = heapq.heapop(nodes)
f2, n2 = heapq.heapop(nodes)
ndoe = Node('*', left=n1, right=n2)
heapq.heappush(nodes, (f1 + f2, node))
root = nodes[0][1]
return root
def solution(operations):
answer = []
res = []
for i in range(len(operations)):
if operations[i][0] == "I":
heapq.heappush(res, int(operations[i][2:]))
if operations[i][0] == "D":
if len(res) == 0:
continue
if operations[i][2] == "-":
a = heapq.heappop(res)
else:
heapq._heapify_max(res)
t = heapq._heappop_max(res)
heapq.heapify(res)
if len(res) >= 2:
heapq._heapify_max(res)
t = heapq._heappop_max(res)
answer.append(t)
heapq.heapify(res)
answer.append(heapq.heappop(res))
elif len(res) == 1:
t = heapq.heapop(res)
answer.extend((t, t))
else:
answer.extend((0, 0))
return answer
def kth_largest(arr, k):
if not arr or k <= 0 or k > len(arr): return -1
min_heap = []
for i, v in enumerate(arr):
heapq.heappush(min_heap, (v, i))
if len(min_heap) > k: heapq.heappop(min_heap)
return heapq.heapop(min_heap)[1]
def addNum(self, num: int) -> None:
heapq.heappush(self.max_lo, (-num, num))
_, max_lo_balanced = heapq.heapop(self.max_lo)
heapq.heappush(self.min_hi, max_lo_balanced)
if len(self.max_lo) < len((self.min_hi)):
min_hi_balanced = heapq.heappop(self.min_hi)
heapq.heappush(self.max_lo, (-min_hi_balanced, min_hi_balanced))
def merge_nodes(self): while (len(self.heap) > 1): node1 = heapq.heappop(self.heap) node2 = heapq.heapop(self.heap) merged = HeapNode(None, node1.freq + node2.freq) merged.left = node1 merged.right = node2 heapq.heappush(self.heap, merged)
def findKthLargest2(self, nums, k):
"""Purpose: Finds kth *largest* element in array.
Note: Python's heapq module supports min-heap.
Therefore, there is a way to efficiently max-heap
and pop from root.
"""
heapq.heapify(nums)
for i in range(n - k):
heapq.heappop(nums)
return heapq.heapop(nums)
def dijkstra():
q = []
heapq.heappush(q,(0,1)) #(distance,node)
dist[1] = 0
while q:
cur_dist, node = heapq.heapop(q)
if cur_dist[node] < dist:
continue
for i in graph[node]:
result = cur_dist + i[0]
if result < dist[i[1]]:
dist[i[1]] = result
heapq.heappush(q,(cur_dist,i[1]))
def sort_k_messed_array2(arr, k):
idx = 0
min_heap = []
for num in arr:
heapq.heappush(min_heap, num)
if len(min_heap) > k:
elt = heapq.heappop(min_heap)
arr[idx] = elt
idx += 1
for _ in range(len(min_heap)):
elt = heapq.heapop(min_heap)
arr[idx] = elt
idx += 1
return arr
def dijkstra(start):
q = []
#시작 노드로 가기 위한 최단 경로는 0으로 설정하여 큐에 삽입
heapq.heappush(q, (0, start))
distance[start] = 0
while q: #q 가 비어 있지 않다면
#가장 최단 거리가 짧은 노드에 대한 정보 꺼내기
dist, now = heapq.heapop(q)
#현재 노드가 이미 처리된적 있다면 무시
if distance[now] < dist:
continue
#현재 노드와 연결된 다른 인접한 노드들을 확인
for i in graph[now]:
cost = dist + i[i]
#현재 노드를 거쳐서, 다른 노드로 이동하는 거리가 더 짧은 경우
if cost < distance[i[0]]:
distance[i[0]] = cost
heapop.heappush(q, (cost, i[0]))
def dijkstra():
delta = [(-1,0),(1,0),(0,-1),(0,1)]
queue = list()
min_path[0][0] = 0
heapq.heappush(queue,(min_path[0][0],0,0))
while queue:
cw,cr,cc = heapq.heapop(queue)
# 최소 비용 가지고 왔으니까....
# 현재 위치에서 갈 수 있는 경로 넣어주기
for dr,dc in delta:
nr,nc = cr+dr,cc+dc
if 0<= nr <N and 0<= nc <N:
# 현재 위치의 누적 가중치 + 다음 위치의 깊이
tmp_V = cw + road[nr][nc]
if min_path[nr][nc] > tmp_V:
min_path[nr][nc] = tmp_V
heapq.heappush(queue,(min_path[nr][nc],nr,nc))
return min_path[N-1][N-1]
def addNum(self, num):
if len(self.maxHeap) == 0:
heapq.heappush(self.maxHeap, -num)
return
if len(self.minHeap) == len(self.maxHeap):
if num < self.minHeap[0]:
heapq.heappush(self.maxHeap, -num)
else:
heapq.heappush(self.minHeap, num)
elif len(self.minHeap) - len(self.maxHeap) >= 1:
if num < self.minHeap[0]:
heapq.heappush(self.maxHeap, -num)
else:
heapq.heappush(self.minHeap, num)
heapq.heappush(self.maxHeap, -heapq.heappop(self.minHeap))
elif len(self.maxHeap) - len(self.minHeap) >= 1:
if num > -self.maxHeap[0]:
heapq.heappush(self.minHeap, num)
else:
heapq.heappush(self.maxHeap, -num)
heapq.heappush(self.minHeap, -heapq.heapop(self.maxHeap))
heapq.heapify(ls1) heapq.heapify(ls2) i=int(input()) while i!=0: res=[] if i != -1: if abs(len(ls1)-len(ls2))<=1: if i>(-1*heapq.heappop(ls1)) : heapq.heappush(ls2,i) else: heapq.heappush(ls1,-1*i) else: if len(ls1)>len(ls2): heapq.heappush(ls2,i) else: heapq.heappush(ls1,-1*i) else: ress=0 if len(ls1) == len(ls2): ress=heapq.heapop(ls1) else: aa=heapq.heappop(ls1) bb=heapq.heappop(ls2) if aa>bb: ress=bb else: ress=aa res.append(ress) gres.append(res) print(grep)
import heapq
n = int(input())
heap = []
for _ in range(n):
data = int(input())
if data == 0:
if heap:
print(heapq.heapop(heap))
else:
print(0)
else:
heapq.heappush(heap, data)
# Meeting Rooms Leetcode # Code: # Approach: Put the end time of the first meeting into the heap. Then iterate over the 2nd until the last meeting and make sure to check the start times of the meetings with the top element in the heap. import heapq def problem(self, arr): -> int #base case: If not arr: return 0 arr.sort(key = lambda x: x[0]) #heap res = [arr[0][1]] For meeting in arr[1:]: If meeting[0]>=res[0]: heapq.heapop(res) heapq.heappush(res, meeting[1]) return len(res) # TC: O(nlogn) # SC: O(n)
import heapq
class MedianFinder(object):
def __init__(self):
self.max_heap = []
self.min_heap = []
def addNum(self, num):
if not self.max_heap or num > -self.max_heap[0]:
heapq.heappush(self.min_heap, num)
if len(self.min_heap) > len(self.max_heap) + 1:
heapq.heappush(self.max_heap, -heapq.heapop(self.min_heap))
else:
heapq.heappush(self.max_heap, -num)
if len(self.max_heap) > len(self.min_heap):
heapq.heappush(self.min_heap, -heapq.heapop(self.max_heap))
def findMedian(self):
if len(self.max_heap) == len(self.min_heap):
return (-self.max_heap[0]+self.min_heap[0] )/2.0
else:
return self.min_heap[0]
