def dijkstra(adjlst, cost, s, t):
q = [] #priority queue
d = {s: 0} #Stores the minimal distances
qd = {} #stores the distance the parent and the vertex
p = {} #Stores previously visited vertex
visited = set([s])
for v in adjlst.get(s, []):
d[v] = cost[s, v]
item = [d[v], s, v]
heapq.heappush(q, item) #push item onto heap
qd[v] = item
while q:
costs, parent, u = heapq.heappop(q)
#u is the current vertex
if u not in visited: #Check to see we havent already gone to u
p[u] = parent #sets u's predecessor vertex
visited.add(u)
if u == t: #Check to see if we're at the last vertex
return p, d[u]
for v in adjlst.get(u, []):
if d.get(v): #Dijkstra algorithm
if d[v] > (cost[u, v] + d[u]):
d[v] = cost[u, v] + d[u]
qd[v][0] = d[v]
qd[v][1] = u
heapq._siftdown(q, 0, q.index(qd[v]))
else:
d[v] = cost[u, v] + d[u]
item = [d[v], u, v]
heapq.heappush(q, item)
qd[v] = item
return None
def getSkyline(self, buildings):
"""
:type buildings: List[List[int]]
:rtype: List[List[int]]
"""
scan = []
for b in buildings:
scan.append([b[0], -b[2]])
scan.append([b[1], b[2]])
scan.sort(key=cmp_to_key(lambda a, b: a[0] - b[0] if a[0] != b[0] else a[1] - b[1]))
q = PriorityQueue()
q.put(0)
ans = []
prev = None
for h in scan:
if h[1] < 0:
q.put(h[1])
else:
index = q.queue.index(-h[1])
q.queue[index] = -2147483647
_siftdown(q.queue, 0, index)
q.get()
top = -q.queue[0]
if top != prev:
ans.append([h[0], top])
prev = top
return ans
def getSkyline(self, buildings):
"""
:type buildings: List[List[int]]
:rtype: List[List[int]]
"""
points = []
for b in buildings:
points.append((b[0], -b[2]))
points.append((b[1], b[2]))
points.sort(key=lambda x: (x[0], x[1]))
# Current height
prev = 0
pq = [0]
results = []
for p in points:
if p[1] < 0:
heapq.heappush(pq, p[1])
else:
if -p[1] in pq:
i = pq.index(-p[1])
pq[i] = pq[-1]
pq.pop()
if i < len(pq):
heapq._siftup(pq, i)
heapq._siftdown(pq, 0, i)
current = -pq[0]
if prev != current:
results.append((p[0], current))
prev = current
return results
def remove_element_from_heap(self, heap, element):
index = heap.index(element)
heap[index] = heap[-1]
del heap[-1]
if index < len(heap):
heapq._siftup(heap, index)
heapq._siftdown(heap, 0, index)
def findDistance(src, trg): # Dijkstra's shortest path algorithm
success = False
distance = -1
vis = [False for i in range(len(graph))] # tracks the visited nodes
# creating and initializing the priority queue
pq = []
heapq.heappush(pq, (0, src))
while (len(pq) > 0 and not success):
cNode = heapq.heappop(pq)
if (cNode[1] == trg): # terminate if we reach the destination
success = True
distance = cNode[0]
break
else:
vis[cNode[1]] = True # setting visited to True
nbrs = list(zip(graph.iloc[cNode[1], 1], graph.iloc[cNode[1], 2]))
for id, dist in nbrs: # iterate over its neighbors
if (not vis[id]): # only check unvisited nodes
nInd = isInQ(pq, id)
# if the new node is in the priority queue, we update its weight if the new weight is lower
if ((nInd[0] >= 0)):
if ((nInd[1] > cNode[0] + dist)):
pq[nInd[0]] = (cNode[0] + dist, id)
# if the new weight is less than the current weight, move up and swap with the parent if needed
heapq._siftdown(pq, 0, nInd[0])
else: # if the new node is not the priority queue, we push it in
heapq.heappush(pq, (cNode[0] + dist, id))
return distance
def remove(self, heap, toRemove):
index = heap.index(toRemove)
heap[index] = heap[-1]
del heap[-1]
if index < len(heap):
_siftup(heap, index)
_siftdown(heap, 0, index)
def delete_num(heap, n):
idx = heap.index(n)
heap[idx] = heap[-1]
heap.pop()
if idx < len(heap):
heapq._siftup(heap, idx)
heapq._siftdown(heap, 0, idx)
def getSkyline(self, buildings):
"""
:type buildings: List[List[int]]
:rtype: List[List[int]]
"""
hs = []
heap = []
for b in buildings:
hs.append((b[0], -b[2]))
hs.append((b[1], b[2]))
hs.sort()
ans = []
pre = cur = None
for h in hs:
pos = h[0]
height = h[1]
if height < 0:
heapq.heappush(heap, height)
else:
i = heap.index(-height)
heap[i] = heap[-1]
heap.pop()
if i < len(heap):
heapq._siftup(heap, i)
heapq._siftdown(heap, 0, i)
if heap:
cur = heap[0]
if cur != pre:
ans.append((pos, -1 * cur))
pre = cur
else:
ans.append((pos, 0))
return ans
def remove_from_front_most_tokens_first(self, node: CovNode):
i = self._front.index(node)
self._front[i] = self._front[-1]
self._front.pop()
if i < len(self._front):
heapq._siftup(self._front, i)
heapq._siftdown(self._front, 0, i)
def remove(heap, num):
index = heap.index(num)
heap[index] = heap[-1]
heap.pop()
if index < len(heap):
heapq._siftup(heap, index)
heapq._siftdown(heap, 0, index)
def spanning(edges, s):
Q = []
for key in edges[s]:
Q.append([edges[s][key], key, s])
T = []
heapq.heapify(Q)
visited = set([s])
c = 0
while len(Q) != 0:
c += 1
entry = heapq.heappop(Q)
node = entry[1]
T.append(entry)
visited.add(node)
neigh = set(edges[node].keys())
for i in range(len(Q)):
if Q[i][1] in neigh:
neigh.remove(Q[i][1])
if edges[node][Q[i][1]] < Q[i][0]:
Q[i][0] = edges[node][Q[i][1]]
Q[i][2] = node
heapq._siftdown(Q, 0, i)
for place in neigh:
if place not in visited:
heapq.heappush(Q, [edges[place][node], place, node])
#sleta efter Qn som får en kortare väg nu
return T
def getSkyline2(self, buildings: [[int]]) -> [[int]]:
points = []
for b in buildings:
points.append((b[0], -b[2]))
points.append((b[1], b[2]))
points.sort(key=lambda x: (x[0], x[1]))
print(points)
# prev stores the current height
prev = 0
pq = [0]
results = []
for p in points:
if p[1] < 0:
heapq.heappush(pq, p[1])
else:
if -p[1] in pq: ## 这里会展现一下怎么用heap自带的func进行指定元素的删除
i = pq.index(-p[1])
pq[i] = pq[-1]
pq.pop()
if i < len(pq):
heapq._siftup(pq, i)
heapq._siftdown(pq, 0, i)
current = -pq[0]
if prev != current:
results.append((p[0], current))
prev = current
return results
def update_priorities(self, idxes, priorities):
"""Update priorities of sampled transitions.
sets priority of transition at index idxes[i] in buffer
to priorities[i]. After the priorities are updated, the
order of elements in the buffer changes.
Parameters
----------
idxes: [int]
List of idxes of sampled transitions
priorities: [float]
List of updated priorities corresponding to
transitions at the sampled idxes denoted by
variable `idxes`.
"""
assert len(idxes) == len(priorities)
# Prepare for update.
if self._max_priority is None:
self._max_priority = -np.inf
new_samples = []
for idx, priority in zip(idxes, priorities):
assert priority > 0
assert 0 <= idx < len(self._storage)
new_samples.append(
self.HeapNode(-priority**self._alpha, self._storage[idx].data))
self._storage[idx].priority = -np.inf
self._max_priority = max(self._max_priority, priority)
for idx in sorted(idxes):
heapq._siftdown(self._storage, 0, idx)
for sample in new_samples:
heapq.heappushpop(self._storage, sample)
def maxSlidingWindow(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: List[int]
"""
if not nums:
return []
res = []
heap = []
import heapq
for num in nums[:k]:
heapq.heappush(heap, -num)
res.append(-heap[0])
i = 0
while i + k < len(nums):
index = heap.index(-nums[i])
heap[index], heap[-1] = heap[-1], heap[index]
heap.pop()
if index < len(heap):
heapq._siftup(heap, index)
heapq._siftdown(heap, 0, index)
heapq.heappush(heap, -nums[i + k])
i += 1
res.append(-heap[0])
return res
def solve(): n = int(raw_input()) a = [] latest = [] a = map(Rev, a) heapq.heapify(a) for i in xrange(n): query = raw_input().split() if len(query) == 2: size = int(query[1]) heapq.heappush(a, Rev(size)) latest.append(size) elif query[0] == 'Q': if latest: print a[0].obj else: print "Empty" else: if latest: x = latest.pop() i = a.index(Rev(x)) a[i] = a[-1] a.pop() try: heapq._siftup(a, i) heapq._siftdown(a,0,i) except IndexError: None
def prim(graph, costs, start):
items = {}
pq = []
for i in graph.keys():
if i == start: continue
item = [float('inf'), i]
items[i] = item
pq.append(item)
heapq.heapify(pq)
start_item = [0, start]
heapq.heappush(pq, start_item)
pre = {start: None}
visited = set()
while pq:
_, u = heapq.heappop(pq)
visited.add(u)
for v in graph[u]:
if v not in visited and costs[u, v] < items[v][0]:
items[v][0] = costs[u, v]
pre[v] = u
heapq._siftdown(pq, 0, pq.index(items[v]))
return pre
def shortest_paths(self, node):
dist = []
heapitems = dict()
previous = dict()
shortest_paths = dict()
for n in self.nodes():
item = [float('inf'), n]
heapq.heappush(dist, item)
previous[n] = []
heapitems[n] = item
heapitems[node][0] = 0
heapq._siftdown(dist, 0, dist.index(heapitems[node]))
while dist:
cost, n = heapq.heappop(dist)
if cost == float('inf'):
break
shortest_paths[n] = previous[n]
for neighbor, edge_cost in self.neighbors(n):
alt = cost + edge_cost
if alt < heapitems[neighbor][0]:
heapitems[neighbor][0] = alt
previous[neighbor] = previous[n] + [neighbor]
heapq._siftdown(dist, 0, dist.index(heapitems[neighbor]))
return shortest_paths
def shortest_path(g,s):
v = {}
add = s
w = []
for e in list(g):
if e != s:
w.append([1000000,e])
heapq.heapify(w)
v[s] = 0
while w:
#update
for e in g[add]:
for f in list(e):
i = 0
while i < len(w):
if w[i][1] == f and w[i][0] > v[add] + e[f]:
w[i] = w[-1]
w.pop()
if i < len(w):
heapq._siftup(w, i)
heapq._siftdown(w, 0, i)
heapq.heappush(w, [v[add] + e[f], f])
i += 1
j = heapq.heappop(w)
add = j[1]
v[add] = j[0]
return v
def modify_key(self, index, new_key):
old_key = self.heap[index][0]
self.heap[index][0] = new_key
if old_key > new_key:
heapq._siftdown(self.heap, 0, index)
elif old_key < new_key:
heapq._siftup(self.heap, index)
def dijsktra(graph, s,t):
Q=[]
d={s:0}
Qd={}
p={}
visited_set=set([s])
for v in graph.adjlist[s]:
d[v]=edgelist[s,v]
item=[d[v],s,v]
if v.bool==0:
heap.heappush(Q,item)
Qd[v]=item
while Q:
cost, parent, u = heapq.heappop(Q)
if u not in visited_set:
p[u]= parent
visited_set.add(u)
if u == t:
return p, d
for v in graphadjlist[u]:
if d.get(v):
if d[v] > graph.edjelist[u, v] + d[u] and v.bool==0:
d[v] = costs[u, v] + d[u]
Qd[v][0] = d[v]
Qd[v][1] = u
heapq._siftdown(Q, 0, Q.index(Qd[v]))
else:
d[v] = costs[u, v] + d[u]
item = [d[v], u, v]
heapq.heappush(Q, item)
Qd[v] = item
return None
def modify_key(self, index, new_key):
old_key = self.heap[index][0]
self.heap[index][0] = new_key
if old_key > new_key:
heapq._siftdown(self.heap, 0, index)
elif old_key < new_key:
heapq._siftup(self.heap, index)
def replace(self, node):
if node.state not in self:
raise ValueError('{} not there to replace'.format(node.state))
for (i, (cost, old_node)) in enumerate(self.heap):
if old_node.state == node.state:
self.heap[i] = (self.costfn(node), node)
heapq._siftdown(self.heap, 0, i)
return
def remove(self, heap, num):
idx = heap.index(num)
heap[idx] = heap[-1]
heap.pop()
if idx < len(heap):
heapq._siftup(heap, idx)
heapq._siftdown(heap, 0, idx)
def remove(self, heap, num):
index = heap.index(num)
heap[index] = heap[-1]
del heap[-1]
if index < len(heap):
heapq._siftup(heap, index)
heapq._siftdown(heap, 0, index)
def delete(self, heap, element):
index = heap.index(element)
heap[index] = heap[-1]
del heap[-1]
if index < len(heap):
_siftup(heap, index)
_siftdown(heap, 0, index)
def heapdelete(heap, value): # 删除堆中指定元素
if value == heap[-1]:
return heap.pop()
node_index = heap.index(value)
heap[node_index] = heap[-1]
heap.pop()
heapq._siftup(heap, node_index) #不断和子节点比，让子节点上浮
heapq._siftdown(heap, 0, node_index) # 注意_siftdown是使父节点往下移动
def remove(self, heap, element):
idx = heap.index(element)
heap[idx] = heap[-1]
del heap[-1]
if idx < len(heap):
heapq._siftup(heap, idx)
heapq._siftdown(heap, 0, idx)
def heap_delete(self,heap,value):
if value == heap[-1]:
return heap.pop()
node_index = heap.index(value)
heap[node_index] = heap[-1]
heap.pop()
heapq._siftup(heap,node_index)
heapq._siftdown(heap,0,node_index)
def remove(self, val):
idx = self.heap.index(-val)
self.heap[idx] = self.heap[0]
self.pop()
#heapq.heapify(self.heap)
if idx < len(self.heap):
heapq._siftup(self.heap, idx)
heapq._siftdown(self.heap, 0, idx)
def replace(self, node):
"""Replace a previous node by this node with the same state."""
for i, (f_value, old_node) in enumerate(self.heap):
if node.state == old_node.state:
self.heap[i] = [self.f(node), node]
heapq._siftdown(self.heap, 0, i)
self.state_nodes[tuple(node.state)] = node # Update state-node
def del_ele_in_heap(heap, ele):
# https://stackoverflow.com/questions/10162679/python-delete-element-from-heap
i = heap.index(ele)
heap[i] = heap[-1]
heap.pop()
if i < len(heap):
heapq._siftup(heap, i)
heapq._siftdown(heap, 0, i)
def repos(self, value, new_key):
for i in range(len(self.q)):
if self.q[i][1] == value:
break
else:
assert False, "No such key in priority queue"
self.q[i][0] = new_key
hq._siftdown(self.q, 0, i) # accessing protected member is all right
def heap_delete(h: list, i):
# from https://stackoverflow.com/questions/10162679/python-delete-element-from-heap
# this is O(logn)
h[i] = h[-1]
h.pop()
if i < len(h):
heapq._siftup(h, i)
heapq._siftdown(h, 0, i)
def remove(self, heap, element):
# instead of heapify all heap, only heapify the element between root and del_index
del_index = heap.index(element)
heap[del_index] = heap[-1]
del heap[-1]
if del_index < len(heap):
heapq._siftup(heap, del_index)
heapq._siftdown(heap, 0, del_index)
def _remove_point(self, heights, point):
for i in range(len(heights)):
if (point[1]) == (heights[i]):
heights[i] = heights[-1]
heights.pop()
if i < len(heights):
heapq._siftup(heights, i)
heapq._siftdown(heights, 0, i)
break
def decrease_key(frontier, old_cost, new_cost, move):
index = frontier.index((old_cost, move))
if index == len(frontier) - 1:
frontier[index] = (new_cost, move)
heapq._siftdown(frontier, 0, len(frontier) - 1)
else:
frontier[index] = frontier.pop()
heapq._siftup(frontier, index)
heapq.heappush(frontier,(new_cost, move))
def heapremove(heap,item):
"""
Removes item from heap.
(This function is missing from the standard heapq package.)
"""
i=heap.index(item)
lastelt=heap.pop()
if item==lastelt:
return
heap[i]=lastelt
heapq._siftup(heap,i)
if i:
heapq._siftdown(heap,0,i)
def remove(self, value):
index = None
for i in range(len(self.elements)):
if self.elements[i][1] == value:
index = i
break
if index is None:
return
lastelt = self.elements.pop()
if index == len(self.elements):
return
self.elements[index] = lastelt
heapq._siftup(self.elements, index)
# https://stackoverflow.com/questions/10162679/python-delete-element-from-heap
heapq._siftdown(self.elements, 0, index)
def _rank_cycle_function(self, cycle, function, ranks):
"""Dijkstra's shortest paths algorithm.
See also:
- http://en.wikipedia.org/wiki/Dijkstra's_algorithm
"""
import heapq
Q = []
Qd = {}
p = {}
visited = set([function])
ranks[function] = 0
for call in compat_itervalues(function.calls):
if call.callee_id != function.id:
callee = self.functions[call.callee_id]
if callee.cycle is cycle:
ranks[callee] = 1
item = [ranks[callee], function, callee]
heapq.heappush(Q, item)
Qd[callee] = item
while Q:
cost, parent, member = heapq.heappop(Q)
if member not in visited:
p[member] = parent
visited.add(member)
for call in compat_itervalues(member.calls):
if call.callee_id != member.id:
callee = self.functions[call.callee_id]
if callee.cycle is cycle:
member_rank = ranks[member]
rank = ranks.get(callee)
if rank is not None:
if rank > 1 + member_rank:
rank = 1 + member_rank
ranks[callee] = rank
Qd_callee = Qd[callee]
Qd_callee[0] = rank
Qd_callee[1] = member
heapq._siftdown(Q, 0, Q.index(Qd_callee))
else:
rank = 1 + member_rank
ranks[callee] = rank
item = [rank, member, callee]
heapq.heappush(Q, item)
Qd[callee] = item
def clean(self, running, queue):
"""if the running time is too long, reassign the job
and mark the worker permanently failed
"""
atimer = Timer('Clean')
if len(running) == 0: return
for job, val in running.items():
if time() - val[0] > self.config['timeout']:
if self.config['verbosity'] >= 6:
print('Time out, marking worker '+str(val[1].id)+' faulty')
heapq.heappush(queue, job)
del running[job]
idx = self.workers.index(val[1])
self.workers[idx].setFaulty()
heapq._siftdown(self.workers, 0, idx)
self.nActive -= 1
def dijkstra(adj, costs, s, t):
#Q is the priority queue.
Q = []
# vertex : minimal distance
d = {s: 0}
# vertex : [d[v], parent_v, v] {distances from parent node.}
Qd = {}
# predecessor
p = {}
visited_set = set([s])
for v in adj.get(s, []):
d[v] = costs[s, v]
item = [d[v], s, v]
heapq.heappush(Q, item)
Qd[v] = item
while Q:
#print Q
cost, parent, u = heapq.heappop(Q)
if u not in visited_set:
print 'selected node:', u
p[u]= parent
visited_set.add(u)
if u == t:
return p, d[u]
for v in adj.get(u, []):
if d.get(v):
if d[v] > costs[u, v] + d[u]:
d[v] = costs[u, v] + d[u]
Qd[v][0] = d[v]
Qd[v][1] = u
heapq._siftdown(Q, 0, Q.index(Qd[v]))
else:
d[v] = costs[u, v] + d[u]
item = [d[v], u, v]
heapq.heappush(Q, item)
Qd[v] = item
return None
def _pop(self, index):
if index:
last_item = super(Heap, self).pop()
if index == len(self):
return_item = last_item
else:
return_item = self[index]
self[index] = last_item
if self[(index - 1) >> 1] < last_item:
_siftup(self, index)
else:
_siftdown(self, 0, index)
return return_item
lastelt = super(Heap, self).pop()
if self:
returnitem = self[0]
self[0] = lastelt
_siftup(self, 0)
else:
returnitem = lastelt
return returnitem
def dijkstra(adj, costs, s, t):
''' Return predecessors and min distance if there exists a shortest path
from s to t; Otherwise, return None '''
Q = [] # priority queue of items; note item is mutable.
d = {s: 0} # vertex -> minimal distance
Qd = {} # vertex -> [d[v], parent_v, v]
p = {} # predecessor
visited_set = set([s])
for v in adj.get(s, []):
d[v] = costs[s, v]
item = [d[v], s, v]
heapq.heappush(Q, item)
Qd[v] = item
while Q:
print Q
cost, parent, u = heapq.heappop(Q)
if u not in visited_set:
print 'visit:', u
p[u]= parent
visited_set.add(u)
if u == t:
return p, d[u]
for v in adj.get(u, []):
if d.get(v):
if d[v] > costs[u, v] + d[u]:
d[v] = costs[u, v] + d[u]
Qd[v][0] = d[v] # decrease key
Qd[v][1] = u # update predecessor
heapq._siftdown(Q, 0, Q.index(Qd[v]))
else:
d[v] = costs[u, v] + d[u]
item = [d[v], u, v]
heapq.heappush(Q, item)
Qd[v] = item
return None
def checkio(bunker):
w, h = len(bunker[0]), len(bunker)
bats = []
dis = dict()
adj = defaultdict(list)
for i in xrange(h):
for j in xrange(w):
if bunker[i][j] == 'B':
bats.append((i, j))
elif bunker[i][j] == 'A':
alpha_i = len(bats)
bats.append((i, j))
for i in xrange(len(bats)):
for j in xrange(i):
d = cal_dis(bunker, bats[i], bats[j])
if d is not None:
dis[i, j] = dis[j, i] = d
adj[i].append(j)
adj[j].append(i)
bat_list = map(Bat, xrange(len(bats)))
dijkstra = bat_list[:]
bat_list[alpha_i].dis = 0
heapq.heapify(dijkstra)
while True:
cur = heapq.heappop(dijkstra)
if bats[cur.idx] == (0, 0):
return cur.dis
for adj_bat in adj[cur.idx]:
if cur.dis + dis[cur.idx, adj_bat] < bat_list[adj_bat].dis:
bat_list[adj_bat].dis = cur.dis + dis[cur.idx, adj_bat]
heapq._siftdown(dijkstra, 0, dijkstra.index(bat_list[adj_bat]))
return float("inf")
def notify_on(self, o, what):
it = self.blockers.pop_from(o)
i = self.sleepers.index(it)
self.sleepers[i] = (0, it[1], what)
_siftdown(self.sleepers, 0, i)
def push(self, item):
if item in self._indexes:
raise RuntimeError('same value not allowed to be inserted twice.')
self.append(item)
_siftdown(self, 0, len(self)-1)
def push(self, value):
if value in self._indexes:
raise RuntimeError('same value not allowed to be inserted twice.')
self.append((self.key(value), value))
_siftdown(self, 0, len(self)-1)
def remove(self, index):
temp = heapq.heappop(self.heap)
if index > 0:
self.heap[index - 1] = temp
# note: _siftup(heap, index) is for making larger terms go towards the leafs
heapq._siftdown(self.heap, 0, index - 1)
