def solveGreedy(game, over, dir):
estimation = manhattanDistance(game, over)
max = 0
caminho[AuxFunctions.returnString(game)] = AuxFunctions.returnString(game)
distancias = []
# Implementacao de heap em ordem das distancias
heapq.heapify(distancias)
heapq.heappush(distancias, (estimation, game))
while not len(distancias) == 0:
node = heapq.heappop(distancias)
repetidos[AuxFunctions.returnString(node[1])] = 1
index = node[1].index(0)
for value in dir[index]:
# Troca de elementos, acedendo a segunda posicao do tuplo
node1 = node[1][:]
node1[index + value], node1[index] = node1[index], node1[index + value]
node1String = AuxFunctions.returnString(node1)
if not caminho.get(node1String):
caminho[node1String] = AuxFunctions.returnString(node[1])
dis = manhattanDistance(node1, over)
if dis == 0:
print "Tiveram em dada altura um maximo de", max, "nos na fila."
return node
if not repetidos.get(node1String):
heapq.heappush(distancias, (dis, node1[:]))
if len(distancias) > max:
max = len(distancias)
def _cases(doc, form):
if isinstance(form, String):
generators = [_forms.get(form.get_string_value())]
elif form.get_head_name() == 'System`Alternatives':
if not all(isinstance(f, String) for f in form.leaves):
return # error
generators = [_forms.get(f.get_string_value()) for f in form.leaves]
elif form.get_head_name() == 'System`Containing':
if len(form.leaves) == 2:
for t in _containing(doc, *form.leaves):
yield t
return
else:
return # error
else:
return # error
def try_next(iterator):
try:
return next(iterator)
except StopIteration:
return None
feeds = []
for i, iterator in enumerate([iter(generator(doc)) for generator in generators]):
t = try_next(iterator)
if t:
feeds.append((_position(t), i, t, iterator))
heapq.heapify(feeds)
while feeds:
pos, i, token, iterator = heapq.heappop(feeds)
yield token
t = try_next(iterator)
if t:
heapq.heappush(feeds, (_position(t), i, t, iterator))
def imerge(iterables):
"""Merge-sorts items from a list of iterators.
"""
_heappop, _heapreplace, _StopIteration = heappop, heapreplace, StopIteration
h = []
h_append = h.append
for itnum, it in enumerate(map(iter, iterables)):
try:
next = it.next
h_append([next(), itnum, next])
except _StopIteration:
pass
heapify(h)
while 1:
try:
while 1:
v, itnum, next = s = h[0] # raises IndexError when h is empty
yield v
s[0] = next() # raises StopIteration when exhausted
_heapreplace(h, s) # restore heap condition
except _StopIteration:
_heappop(h) # remove empty iterator
except IndexError:
return
def _merge_file_iters(self, iters, key=lambda x: x):
heap = []
for iter, root in iters:
try:
heap.append((next(iter), iter, root))
except StopIteration:
pass
heapq.heapify(heap)
while heap:
value, iter, root = heapq.heappop(heap)
try:
heapq.heappush(heap, (next(iter), iter, root))
except StopIteration:
pass
items = [(value, root)]
while heap:
cand, iter, root = heapq.heappop(heap)
if key(cand) == key(value):
items.append((cand, root))
try:
heapq.heappush(heap, (next(iter), iter, root))
except StopIteration:
pass
else:
heapq.heappush(heap, (cand, iter, root))
break
yield items
def __getitem__(self, key):
fn = self._fn_cache[key]
ret = feather.read_dataframe(fn)
self._heap_map[key][0] = time.time()
# ensure the heap invariant
heapq.heapify(self._heap)
return ret
def Min_Span_Tree(outside_tree):
#find all edges & put into a priorityQ
heap = []
for pair in itertools.combinations(outside_tree, 2):
heapq.heappush(heap, (Edge(pair), pair))
inside_tree = set()
answer = 0
heapq.heapify(list(outside_tree))
initial = outside_tree.pop()
while outside_tree:
inside_tree.update(initial)
shortest = min([item for item in heap if initial in item[1]])
answer += float(shortest[0])
x, y = shortest[1]
inside_tree.update(x, y)
heap.remove(shortest)
next_point = outside_tree.pop()
initial = next_point
return answer
def imerge(*iterables):
"""
Merge multiple sorted inputs into a single sorted output.
Equivalent to: sorted(itertools.chain(*iterables))
>>> list(imerge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))
[0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
"""
heappop, siftup, _StopIteration = heapq.heappop, heapq._siftup, StopIteration
h = []
h_append = h.append
for it in map(iter, iterables):
try:
_next = it.next
h_append([_next(), _next])
except _StopIteration:
pass
heapq.heapify(h)
while 1:
try:
while 1:
v, _next = s = h[0] # raises IndexError when h is empty
yield v
s[0] = _next() # raises StopIteration when exhausted
siftup(h, 0) # restore heap condition
except _StopIteration:
heappop(h) # remove empty iterator
except IndexError:
return
def _run_until_current(self):
self._insert_new_calledlaters()
now = time.time()
while self._pending_timed_calls and (self._pending_timed_calls[0].time <= now):
call = heapq.heappop(self._pending_timed_calls)
if call.cancelled:
self._cancellations -= 1
continue
if call.delayed_time > 0:
call.activate_delay()
heapq.heappush(self._pending_timed_calls, call)
continue
try:
call.called = 1
call.func(*call.args, **call.kw)
except _reraised_exceptions:
raise
except:
getlog().exception("CallLater failed")
if self._cancellations > 50 and self._cancellations > len(self._pending_timed_calls) >> 1:
self._cancellations = 0
self._pending_timed_calls = [x for x in self._pending_timed_calls if not x.cancelled]
heapq.heapify(self._pending_timed_calls)
def create_binary_tree(self):
"""
Create a binary Huffman tree using stored vocabulary word counts. Frequent words
will have shorter binary codes. Called internally from `build_vocab()`.
"""
logger.info("constructing a huffman tree from %i words" % len(self.vocab))
# build the huffman tree
heap = self.vocab.values()
heapq.heapify(heap)
for i in xrange(len(self.vocab) - 1):
min1, min2 = heapq.heappop(heap), heapq.heappop(heap)
heapq.heappush(heap, Vocab(count=min1.count + min2.count, index=i + len(self.vocab), left=min1, right=min2))
# recurse over the tree, assigning a binary code to each vocabulary word
if heap:
max_depth, stack = 0, [(heap[0], [], [])]
while stack:
node, codes, points = stack.pop()
if node.index < len(self.vocab):
# leaf node => store its path from the root
node.code, node.point = codes, points
max_depth = max(len(codes), max_depth)
else:
# inner node => continue recursion
points = array(list(points) + [node.index - len(self.vocab)], dtype=uint32)
stack.append((node.left, array(list(codes) + [0], dtype=uint8), points))
stack.append((node.right, array(list(codes) + [1], dtype=uint8), points))
logger.info("built huffman tree with maximum node depth %i" % max_depth)
def k_smallest_matrix(matrix, k):
"""
Given a n x n matrix where each of the rows and columns are sorted in ascending order,
find the kth smallest element in the matrix.
:param matrix: A square matrix of size n x n in sorted order for its rows and cols
:param k: The kth-smallest element to look for
:return: An k-th smallest element in the matrix.
"""
# Take the entire first row and heapify it
open_list = [(matrix[y][x], y, x) for x in xrange(len(matrix)) for y in xrange(len(matrix))]
heapq.heapify(open_list)
current_min = None
# Take the min element and enqueue the element below it if possible; when k is 0 we have our k'th min element
while k != 0:
current_min, current_y, current_x = heapq.heappop(open_list)
if y < len(matrix):
heapq.heappush(open_list, (matrix[y][x], current_y, current_x))
k -= 1
return current_min
def __init__(self, heap=[]):
"""if 'heap' is not empty, make sure it's heapified"""
heapq.heapify(heap)
self.heap = heap
self.entry_finder = dict({i[-1]: i for i in heap})
self.REMOVED = '<remove_marker>'
def test_buscar_el_mayor_y_menor_valor_de_una_lista(self): import heapq nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2] tres_mayores = heapq.nlargest(3,nums) self.assertEqual(tres_mayores,[42,37,23]) tres_menores = heapq.nsmallest(3,nums) self.assertEqual(tres_menores,[-4,1,2]) mayor = max(nums) menor = min(nums) self.assertEqual(mayor ,42) self.assertEqual(menor ,-4) heap = list(nums) #Pone el primer elemento en la posicion 0 heapq.heapify(heap) self.assertEqual(heap,[-4, 2, 1, 23, 7, 2, 18, 23, 42, 37, 8]) #heappop saca el primer elemento, y lo sustituye por el menor de la lista # asi heappop siempre sacara el elemento mas pequeño menor =heapq.heappop(heap) self.assertEqual(menor,-4) menor =heapq.heappop(heap) self.assertEqual(menor, 1)
def trapRainWater(self, heightMap):
if not heightMap: return 0
import heapq
m, n = len(heightMap), len(heightMap[0])
queue, vis, res = [], [[False]*n for _ in range(m)], 0
for i in range(m):
queue.append((heightMap[i][0], (i,0)))
queue.append((heightMap[i][n-1], (i,n-1)))
vis[i][0] = vis[i][n-1] = True
for i in range(1,n-1):
queue.append((heightMap[0][i], (0,i)))
queue.append((heightMap[m-1][i], (m-1,i)))
vis[0][i] = vis[m-1][i] = True
heapq.heapify(queue)
while queue:
val, loc = heapq.heappop(queue)
res += val - heightMap[loc[0]][loc[1]]
for d in [[-1,0],[0,1],[1,0],[0,-1]]:
tx, ty = loc[0]+d[0], loc[1]+d[1]
if 0 < tx < m and 0 < ty < n and not vis[tx][ty]:
vis[tx][ty] = True
heapq.heappush(queue, (max(val, heightMap[tx][ty]), (tx, ty)))
return res
def skyline(buildings):
if not buildings:
return []
points = []
for l, r, h in buildings:
points.append([l, -h])
points.append([r, h])
# sort the points to ensure that all points are sorted from left to right
points.sort()
result = []
queue = [0]
prev = 0
for e in points:
if e[1] < 0:
# whenever we see start point of the building
# we put the height of the building into the heapq
heapq.heappush(queue, e[1])
else:
# if we arrive at the end point of the building
# we remove the height of the building from the heapq
if queue[0] == -e[1]:
heapq.heappop(queue)
else:
queue.remove(-e[1])
heapq.heapify(queue)
curr = queue[0]
if curr != prev:
# if the tallest building in the heapq changes
# then we need to put that into the final result
result.append([e[0], -curr])
prev = curr
return result
def __init__(self, ls = []):
''' ls is a list of tuples in this format
[ (val, label), (val, label), ... ]
'''
# multiply val by -1 to make this into a max heap, heapq is min heap
self.heap = [ [-1 * val, label] for val, label in ls ]
heapq.heapify(self.heap)
def remove_at(self, index):
"""Removes item at given index"""
with self.lock:
item = self.items.pop(index)[0]
heapq.heapify(self.items)
return item
def prim_std(G):
"""Input: A connected undirected graph G=(V, E) with edge weights
Output: A minimum spanning tree defined by the dict prev
This prim uses heapq in standard library, with 3 times faster than prim(G).
"""
V, E = G
cost = {}
prev = {}
for u in V:
cost[u] = float("inf")
prev[u] = None
cost[V[0]] = 0
H = [(cost[u], u) for u in V]
heapify(H)
while len(H):
costv, v = heappop(H)
for z in E[v]:
weightVZ = E[v][z]
if cost[z] > weightVZ:
try:
indexZ = H.index((cost[z], z))
except ValueError:
continue
cost[z] = weightVZ
prev[z] = v
print "From <%d> to <%d> cost: %d" % (v,z,weightVZ)
H[indexZ] = (cost[z], z)
heapify(H)
return prev
def iterate (self):
if not len (self.open):
return False
self.solution = heapq.heappop (self.open)
self.waypoints.remove (self.solution)
if self.solution.can_see_goal:
return True
for waypoint in self.waypoints:
if self.solution.dists[waypoint] == -1.0:
continue
new_g = self.solution.g_cost + self.solution.dists[waypoint]
if waypoint in self.open and new_g >= waypoint.g_cost:
continue
waypoint.g_cost = new_g
waypoint.f_cost = waypoint.g_cost + waypoint.h_cost
waypoint.parent = self.solution
if waypoint.can_see_goal:
self.solution = waypoint
return True
if waypoint not in self.open:
# At this point, the heap invariant may be violated, so who
# knows how much better this is than just appending it
heapq.heappush (self.open, waypoint)
heapq.heapify (self.open)
def _build_tree(self, a):
heapq.heapify(a)
while len(a) > 1:
left = heapq.heappop(a)
right = heapq.heappop(a)
heapq.heappush(a, (left[0] + right[0], left, right))
return a[0]
def test_heapify(self):
for size in range(30):
heap = [random.random() for dummy in range(size)]
heapify(heap)
self.check_invariant(heap)
self.assertRaises(TypeError, heapify, None)
def add(self, item):
""" Add *item* to the queue.
If such an item already exists, its priority will be
checked versus *item*. If *item*'s priority is better
(i.e. lower), the priority of the existing item in the
queue will be updated.
Returns True if the item was added or updated.
"""
if not item in self.set:
self.set[item] = item
heapq.heappush(self.heap, item)
return True
elif item < self.set[item]:
# No choice but to search linearly in the heap
#
for idx, old_item in enumerate(self.heap):
if old_item == item:
del self.heap[idx]
self.heap.append(item)
heapq.heapify(self.heap)
self.set[item] = item
return True
return False
def main():
from heapq import heapify, heappush, heappop
M = open('matrix.txt').read().split()
M = [map(int, m.split(',')) for m in M]
H = len(M)
W = len(M[0])
scores = [(M[y][0], 0, y) for y in xrange(H)]
heapify(scores)
R = [[0]*W for _ in xrange(H)]
def next(xx, yy):
if not R[yy][xx]:
ss = M[yy][xx] + s
R[yy][xx] = ss
heappush(scores, (ss, xx, yy))
while scores:
s, x, y = heappop(scores)
if x == W-1:
#for r in R:
# print r
return s
if y > 0:
next(x, y-1)
if y < H-1:
next(x, y+1)
next(x+1, y)
def shortest_paths(neighs, start):
"""
Returns a tuple of two dicts (dists, prevs). Dists contains lengths of
shortest paths from start to all reachable vertices. Prevs contains previous
vertex of the shortest path, which can be easily used to reconstruct the
whole path.
Arguments:
neighs -- dict of dict such that neighs[v1][v2] = d iff there is an edge
from v1 to v2 with length d
start -- the starting vertex
"""
visited = set()
to_visit = [(0, start, None)]
heapq.heapify(to_visit)
prevs = {} # previous vertex of ideal path
dists = {}
while True:
if not to_visit:
return dists, prevs
dist, vertex, prev = heapq.heappop(to_visit)
if vertex in visited: continue
for n in neighs[vertex]:
if n in visited: continue
heapq.heappush(to_visit, (neighs[vertex][n] + dist, n, vertex))
prevs[vertex] = prev
dists[vertex] = dist
visited.add(vertex)
def relax(w, u, v):
global h
global path
for node in h:
d, p, vertex = node
if vertex == v:
d_v = d
for node in path:
d, p, vertex = node
if vertex == u:
d_u = d
elif vertex == v:
d_v = d
if d_v > d_u + w:
d_v = d_u +w
p_v = u
for i in range(len(h)):
_w, _p, _u = h[i]
if _u == v:
h[i] = (d_v, p_v, v)
break
heapq.heapify(h)
def massReschedule(self, reschedule_set):
"""
Reschedule all models provided.
Equivalent to calling unschedule(model); schedule(model) on every element in the iterable.
:param reschedule_set: iterable containing all models to reschedule
"""
#NOTE rather dirty, though a lot faster for huge models
#assert debug("Mass rescheduling")
inf = float('inf')
for model in reschedule_set:
event = self.id_fetch[model.model_id]
if event[2]:
if model.time_next == event[0]:
continue
elif event[0][0] != inf:
self.invalids += 1
event[2] = False
if model.time_next[0] != inf:
self.id_fetch[model.model_id] = [model.time_next,
model.model_id,
True,
model]
heappush(self.heap, self.id_fetch[model.model_id])
#assert debug("Optimizing heap")
if self.invalids >= self.max_invalids:
#assert info("Heap compaction in progress")
self.heap = [i for i in self.heap if i[2] and (i[0][0] != inf)]
heapify(self.heap)
self.invalids = 0
def nthUglyNumber(self, n):
"""
Prime factor: 2, 3, 5
Heap
:type n: int
:rtype: int
"""
if n == 1:
return 1
n -= 1 # exclude 1
ugly = [2, 3, 5]
qs = [Node(i, [i]) for i in ugly]
h = list(qs) # shallow copy
heapq.heapify(h)
cnt = 0
ret = 2
while cnt < n:
cnt += 1
popped = heapq.heappop(h)
ret = popped.q.pop(0)
for i in xrange(ugly.index(popped.origin), 3):
qs[i].q.append(ret*ugly[i])
heapq.heappush(h, popped)
return ret
def __init__(self,source_vertex,vertex_list):
self.pq = []
self.source = source_vertex
for v in vertex_list:
self.pq.append(v)
self.source.min_weight = 0
heapq.heapify(self.pq)
def sweep(self):
"""Clean out stale data
>>> sdc = PersistentSessionDataContainer()
>>> sdc['1'] = SessionData()
>>> sdc['2'] = SessionData()
Wind back the clock on one of the ISessionData's
so it gets garbage collected
>>> sdc['2'].lastAccessTime -= sdc.timeout * 2
Sweep should leave '1' and remove '2'
>>> sdc.sweep()
>>> sd1 = sdc['1']
>>> sd2 = sdc['2']
Traceback (most recent call last):
[...]
KeyError: '2'
"""
# We only update the lastAccessTime every 'resolution' seconds.
# To compensate for this, we factor in the resolution when
# calculating the expiry time to ensure that we never remove
# data that has been accessed within timeout seconds.
expire_time = time.time() - self.timeout - self.resolution
heap = [(v.lastAccessTime, k) for k,v in self.data.items()]
heapify(heap)
while heap:
lastAccessTime, key = heappop(heap)
if lastAccessTime < expire_time:
del self.data[key]
else:
return
def first_k_most_relevant(doc_scores): """If there are more than k documents containing terms in a query, return the k documents with the highest scores, tiebroken by least docID first. If there are less than k documents, return them, sorted by highest scores, and tiebroken by least docID first. O(n) + O(k lg n) :param doc_scores: A dictionary of docID to its corresponding document's score. :return: List of k docIDs of string type, which are the most relevant (i.e. have the highest scores) """ scores = [(-score, docID) for docID, score in doc_scores.iteritems()] # invert the scores so that heappop gives us the smallest score heapq.heapify(scores) most_relevant_docs = [] for _ in range(k): if not scores: break most_relevant_docs.append(heapq.heappop(scores)) if not most_relevant_docs: return most_relevant_docs # deals with equal-score cases kth_score, kth_docID = most_relevant_docs[-1] while scores: next_score, next_docID = heapq.heappop(scores) if next_score == kth_score: most_relevant_docs.append((next_score, next_docID)) else: break return sort_relevant_docs(most_relevant_docs)
def discard(self, item): new_heap = [] for heap_item in self.heap: if item != heap_item.item: new_heap.append(heap_item) self.heap = new_heap heapify(self.heap)
# RPC 08 - Rockabye Tobby [TLE] import heapq if __name__ == '__main__': t = int(input()) for _ in range(t): n, k = [int(x) for x in input().split()] medicines = [] for p in range(n): med = input().split() medicines.append( (med[0], int(med[1]), p) ) result = [] heapq.heapify(result) for i in range(k): for j in range(n): heapq.heappush(result, (medicines[j][1] * (i + 1), medicines[j][2], j) ) for i in range(k): r = heapq.heappop(result) print(r[0], medicines[r[2]][0])
def huffman_encode(arr, save_dir='./'):
"""
Encodes numpy array 'arr' and saves to save_dir
The names of binary files are prefixed with prefix
returns the number of bytes for the tree and the data after the compression
"""
if len(arr) == 0:
return 0, 0
# Infer dtype
dtype = str(arr.dtype)
# Calculate frequency in arr
freq_map = defaultdict(int)
convert_map = {'float32': float, 'int32': int}
for value in np.nditer(arr):
value = convert_map[dtype](value)
freq_map[value] += 1
# Make heap
heap = [
Node(frequency, value, None, None)
for value, frequency in freq_map.items()
]
heapify(heap)
# Merge nodes
while len(heap) > 1:
node1 = heappop(heap)
node2 = heappop(heap)
merged = Node(node1.freq + node2.freq, None, node1, node2)
heappush(heap, merged)
# Generate code value mapping
value2code = dict()
def generate_code(node, code):
if node is None:
return
if node.value is not None:
value2code[node.value] = code
return
generate_code(node.left, code + '0')
generate_code(node.right, code + '1')
root = heappop(heap)
generate_code(root, '')
# Path to save location
directory = Path(save_dir)
# Dump data
data_encoding = ''.join(value2code[convert_map[dtype](value)]
for value in np.nditer(arr))
datasize = dump(data_encoding)
# Dump codebook (huffman tree)
codebook_encoding = encode_huffman_tree(root, dtype)
treesize = dump(codebook_encoding)
return treesize, datasize
def _rebuild_heap(self):
self._heap = [(v, k) for k, v in iteritems(self)]
heapify(self._heap)
from heapq import heappop, heappush, heapify """PYTHON BUILDS MIN HEAPS BY DEFAULT""" heap = [] nums = [12, 3, -5, 14, 20, -100, 55] # for num in nums: # heappush(heap, num) # # while heap: # print(heappop(heap)) heapify(nums) print(nums)
def __init__(self) -> None:
self._heap = []
heapq.heapify(self._heap)
def join(inputs, keyfuncs=None):
"""join(inputs, keyfuncs) --> iterator over tuples of iterators
General join operator over k inputs yields a k-tuple of iterators,
such that at least one iterator is over a non-empty sequence. All
elements in all iterators have the same join key.
The join key is derived from each input value using the keyfunc
parameter. If not provided, the keyfunc defaults to the identity
function for each input. If the keyfunc is indexable, each index
is associated with the corresponding input; otherwise the same
keyfunc will be used for all inputs. Individual keyfuncs that
aren't callable will default to the identity function.
Example with invariant assertions:
inputs = (seq1, seq2, ..., seqN)
keyfuncs = (keyfunc1, keyfunc2, ..., keyfuncN)
for it_nTuple in join(inputs, keyfuncs):
assert len(it_nTuple) == N
itemCount = 0
commonKey = None
for it in it_nTuple:
for i,x in enumerate(it):
itemCount += 1
if itemCount == 1:
commonKey = keyfuncs[i](x)
else:
assert keyfuncs[i](x) == commonKey
assert itemCount >= 1
Special-case join operators:
0/1 join:
def singleItemOrNone(it):
for x in it:
break
else:
return None
for y in it:
raise ValueError('Got more than one element')
else:
return x
for it_nTuple in join((seq1, seq2, ..., seqN)):
yield map(singleItemOrNone, it_nTuple)
"""
n = len(inputs)
iters = map(pushback_iter, inputs)
if keyfuncs is None:
keyfuncs = [None] * n
elif not hasattr(keyfuncs, '__getitem__'):
keyfuncs = [keyfuncs] * n
for i, k in enumerate(keyfuncs):
if not callable(k):
keyfuncs[i] = lambda x: x
import heapq
q = []
for i, it in enumerate(iters):
for v in it:
k = keyfuncs[i](v)
it.push(v)
q.append((k, i, it))
break
heapq.heapify(q)
while q:
k, i, it = q[0]
it_tuple = tuple([
iter_equal_key(it2, k, keyfuncs[j]) for j, it2 in enumerate(iters)
])
yield it_tuple
for x in it_tuple:
for y in x:
pass
while q and q[0][0] == k:
k, i, it = q[0]
for v in it:
nk = keyfuncs[i](v)
it.push(v)
heapq.heapreplace(q, (nk, i, it))
break
else:
heapq.heappop(q)
format(14, '#010b')
{}.format(14, '#010b')
#Fill the string with zeros until it is 10 characters long:
txt = "50"
x = txt.zfill(10)
# sort list
orgList
newList = sorted(orgList, key = lambda x: orgList[x])
# or
orgList.sort(orgList, key = lambda x: orgList[x])
# dict to list
l = list(dict.item())
# min heap: from min to max, maintain len
import heapq
a = [3,2,1]
heapq.heapify(a)
# a become [1,2,3]
if len(heap) < 3:
heapq.heappush(heap, num) # -num if max heap
else:
heapq.heappushpop(heap, num)
# !!!!!!!! heappop to get ordered item
#The traditional solution is to store (priority, task) tuples on the heap:
pq = [ ]
heappush(pq, (10, task1))
heappush(pq, (5, task2))
heappush(pq, (15, task3))
priority, task = heappop(pq)
import heapq H = [21,1,45,78,3,5] # Covert to a heap heapq.heapify(H) print(H) # Add element heapq.heappush(H,8) print(H) heapq.heapify(H) print(H)
def _remove(self, item):
self.queue.remove(item)
heapq.heapify(self.queue)
import sys
import heapq
sys.stdin = open('1715.txt', 'r')
N = int(input())
cards = []
for _ in range(N):
cards += [int(input())]
heapq.heapify(cards)
ans = 0
while len(cards) > 1:
x, y = heapq.heappop(cards), heapq.heappop(cards)
ans += x + y
heapq.heappush(cards, x + y)
print(ans)
This function increase the value by 1
"""
self.count += 1
def __cmp__(self, other):
"""
This function used by heapify to compare the comments based on their frequency
"""
return cmp(self.count, other.count)
revheap = {} # a dictionary of heap
for x in range(12): # 12 for number of months
revheap[x] = list()
heapq.heapify(revheap[x])
alldict = list(
) # list of dictionary for each month to store comment vs review instance
for x in range(12):
alldict.append({})
def getData():
"""
Reading from local postgres db
database name : review
user : postgres
password : root
table : usercomments(comments character varying(20), postdate date)
"""
def pythonHeap(arr: list):
heapq.heapify(arr)
return [heapq.heappop(arr) for _ in range(len(arr))]
def get_degree_heap(graph: nx.Graph):
degrees = [(-d, v) for (v, d) in graph.degree_iter()]
heapq.heapify(degrees)
return degrees
import heapq
from heapq_showtree import show_tree
from heapq_heapdata import data
heapq.heapify(data)
print('start:')
show_tree(data)
for n in [0, 13]:
smallest = heapq.heapreplace(data, n)
print('replace %2d with %2d:' % (smallest, n))
show_tree(data)
def resetHeap(self):
self.heap = self.stack.copy()
heapq.heapify(self.heap)
def __init__(self):
self.back = []
heapq.heapify(self.back)
import heapq
import math
m, n = input().split(' ')
# c=0
n = int(n)
arr = list(map(int, input().split(' ')))
arr = [20, 7, 5, 4]
narr = []
# print(arr)
for i in arr:
narr.append(i * -1)
n = len(arr) - 1
while (n):
n -= 1
heapq.heapify(narr)
ele = heapq.heappop(narr)
# print(ele)
heapq.heappush(narr, math.ceil(ele // 2))
# print(narr)
print(sum(narr) * -1)
from collections import deque
import heapq
import time
array = [6, 2, 8, 1, 3, 9, 4, 5, 10, 7]
heapq.heapify(array)
array = [3, 4, 5, 6, 7, 4, 12, 13, 3]
print(array)
def heapsort(a):
n = len(a)
a = [0] + a
for i in range(int(n / 2), 0, -1):
heapify(a, i, n)
for j in range(n - 1, 0, -1):
a[1], a[j + 1] = a[j + 1], a[1]
heapify(a, 1, j)
def heapify(a, h, m):
root = a[h]
for j in range(2 * h, m - 1, 2):
if j < m and a[j] < a[j + 1]:
j += 1
if root >= a[int(j / 2)]:
break
print(heap) # we can do the same operation by heappreplace() method. small=heapq.heappushpop(heap,(0,"k")) print(small) print(heap) # do that again- small=heapq.heappushpop(heap,(3,"n")) print(small) print(heap) # the difference between heappushpop() and heappreplace() is: # in heappushpop() the pop being performed after the push. # in heappreplace() the pop being performed before the push (in other words, the new # element cannot be returned as the smallest). # we can transform a unordered list to a heap using heapify() method. unordered = [(2,"k"),(0,"g"),(1,"f")] heapq.heapify(unordered) print(unordered) # we can print first n-th largest pair from the heap using nlargest() method. print(heapq.nlargest(3,heap)) # we can print first n-th smallest pair from the heap using nsmallest() method. print(heapq.nsmallest(2,heap)) # we can merge two heap and make them one. merged = list(heapq.merge(heap,unordered)) # NOTE that we have to convert it to list. print(merged)
def finalize(self):
self._final = True
heapq.heapify(self._l)
def __init__(self, k: int, nums: List[int]):
self.nums = nums
self.k = k
heapq.heapify(self.nums)
while len(self.nums) > self.k:
heapq.heappop(self.nums)
# greedy Huffman's coding algorithm (using weights instead of frequencies of elements)
# printing lengths of the longest and shortest codewords in the resulting Huffman code
import heapq
size = 1000
t = [0]*(size + 1)
with open('huffman.txt', 'r') as doc:
h = 0
for line in doc:
t[h] = int(line)
h += 1
del t[0]
T = t.copy()
print(T)
heapq.heapify(T)
print(T)
shortest = 0
longest = 0
mini = min(t)
maxi = max(t)
while len(T) > 2:
a = heapq.heappop(T)
b = heapq.heappop(T)
if a == mini or b == mini:
longest += 1
mini = a + b
if a == maxi or b == maxi:
shortest += 1
maxi = a + b
heapq.heappush(T, a + b)
def __init__(self, vals=[], key=None):
self.key = (lambda x: x) if key == None else key
self.heap = [(self.key(v), v) for v in vals]
heapify(self.heap)
def ComputePath(listOpen, target, setClose, counter):
while (target.gVal > listOpen[0][0]):
temp = listOpen[0][1]
heapq.heappop(listOpen)
setClose.append(temp)
if (temp.rNode != temp):
if (temp.rNode.search < counter):
temp.rNode.gVal = float('Inf')
temp.rNode.search = counter
if (temp.rNode.gVal > temp.gVal + 1):
temp.rNode.gVal = temp.gVal + 1
temp.rNode.tree = temp
ifRemove = 0
for key in listOpen:
if key[1] == temp.rNode:
listOpen.remove(key)
ifRemove = 1
break
f = temp.rNode.gVal + temp.rNode.h_fun(temp.rNode, target)
if ifRemove == 1:
listOpen.append([f, temp.rNode])
heapq.heapify(listOpen)
else:
heapq.heappush(listOpen, [f, temp.rNode])
if (temp.lNode != temp):
if (temp.lNode.search < counter):
temp.lNode.gVal = float('Inf')
temp.lNode.search = counter
if (temp.lNode.gVal > temp.gVal + 1):
temp.lNode.gVal = temp.gVal + 1
temp.lNode.tree = temp
ifRemove = 0
for key in listOpen:
if key[1] == temp.lNode:
listOpen.remove(key)
ifRemove = 1
break
f = temp.lNode.gVal + temp.lNode.h_fun(temp.lNode, target)
if ifRemove == 1:
listOpen.append([f, temp.lNode])
heapq.heapify(listOpen)
else:
heapq.heappush(listOpen, [f, temp.lNode])
if (temp.uNode != temp):
if (temp.uNode.search < counter):
temp.uNode.gVal = float('Inf')
temp.uNode.search = counter
if (temp.uNode.gVal > temp.gVal + 1):
temp.uNode.gVal = temp.gVal + 1
temp.uNode.tree = temp
ifRemove = 0
for key in listOpen:
if key[1] == temp.uNode:
listOpen.remove(key)
ifRemove = 1
break
f = temp.uNode.gVal + temp.uNode.h_fun(temp.uNode, target)
if ifRemove == 1:
listOpen.append([f, temp.uNode])
heapq.heapify(listOpen)
else:
heapq.heappush(listOpen, [f, temp.uNode])
if (temp.dNode != temp):
if (temp.dNode.search < counter):
temp.dNode.gVal = float('Inf')
temp.dNode.search = counter
if (temp.dNode.gVal > temp.gVal + 1):
temp.dNode.gVal = temp.gVal + 1
temp.dNode.tree = temp
ifRemove = 0
for key in listOpen:
if key[1] == temp.dNode:
listOpen.remove(key)
ifRemove = 1
break
f = temp.dNode.gVal + temp.dNode.h_fun(temp.dNode, target)
if ifRemove == 1:
listOpen.append([f, temp.dNode])
heapq.heapify(listOpen)
else:
heapq.heappush(listOpen, [f, temp.dNode])
# print(len(listOpen))
if len(listOpen) == 0:
return
def __delitem__(self, key):
"""Delete the first occurrence of key."""
self.heap.remove((self.f(key), key))
heapq.heapify(self.heap)
def flood_fill(self, x, y, final_x, final_y):
print("In Flood Fill")
map_img = np.flipud(self.map_array.copy())
unknown_spaces = np.where(map_img == -1) # -1 means unknown
map_img[unknown_spaces] = 100 # turn everything unknown into a wall
# plt.imshow(map_img, cmap='gray', vmin=-1, vmax=100)
# plt.show(True)
# quit()
nodes = [(0, (x, y))]
heapify(nodes)
while nodes:
# pop the node
node = heapq.heappop(nodes)
# print(node)
# get its values
cur_p = node[0]
cur_x, cur_y = node[1]
# update the map object
self.cost_map[cur_x][cur_y] = cur_p
# get neighbors
open_pixels, near_walls = self.get_neighbors(
map_img, cur_x, cur_y, 8)
neighbors = open_pixels + near_walls
# already skipping occupied spaces
for neighbor in neighbors:
n_x = neighbor[0]
n_y = neighbor[1]
n = np.array([n_x, n_y])
# make the path distance the priority
new_p = (cur_p + np.linalg.norm(np.array([cur_x, cur_y]) - n))
# print(idx)
idx = [(a, b) for a, b in near_walls if a == n_x and b == n_y]
if len(idx) > 0:
new_p *= 100
if (n_x, n_y) == (final_x, final_y):
self.cost_map[n_x][n_y] = new_p
print("found the goal")
return True
# if self.near_wall(map_img, n_x, n_y):
# new_p *= new_p # square the distance to disuade path's near walls
# if the block is already seen, possibly update priority
if self.cost_map[n_x][n_y] != np.inf:
# get the p value that matches the node in the heap
old_p = [a for a, b in nodes if (n_x, n_y) == b]
if len(old_p) > 1:
print("Error - quiting")
quit()
if new_p < old_p: # if new distance is shorter than before, update it
idx = nodes.index((old_p[0], (n_x, n_y)))
nodes[idx] = (new_p, (n_x, n_y))
heapify(nodes) # rebalance the heap
else:
self.cost_map[n_x][n_y] = new_p
heapq.heappush(nodes, (new_p, (n_x, n_y)))
# plt.imsave("flood.png", self.cost_map, cmap='gray', vmin=0, vmax=300)
# plt.show()
print("could not find goal")
return False
def _build_heap(self):
newheap = list((v[0], k, v[1]) for k, v in self._dict.items())
heapq.heapify(newheap)
self._heap = newheap
def topKFrequent(self, words, k):
count = collections.Counter(words)
heap = [(-freq, word) for word, freq in count.items()]
heapq.heapify(heap)
return [heapq.heappop(heap)[1] for _ in range(k)]
def __init__(self, k: int, nums: List[int]):
self.pool = nums
self.k = k
heapq.heapify(self.pool)
while len(self.pool) > k:
heapq.heappop(self.pool)
def __init__(self, k, nums):
self.heap = nums
heapq.heapify(self.heap)
self.k = k
