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 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)