def add(self, val: int) -> int: if len(self.stream) < self.k: heappush(self.stream, val) elif val > self.stream[0]: # if the new value is greater than the smallest element in the min heap, # then it's one of the largest elements greater than kth. else it's even smaller, ignore it heappop(self.stream) heappush(self.stream, val) return self.stream[0]
def addNum(self, num: int) -> None: heappush(self.maxHeap, num) heapq._heapify_max(self.maxHeap) topOfMax = heappop(self.maxHeap) heappush(self.minHeap, topOfMax) heapq.heapify(self.minHeap) if len(self.maxHeap) < len(self.minHeap): topOfMin = heappop(self.minHeap) heappush(self.maxHeap, topOfMin)
def construct(tree): while (len(tree) > 1): left = _heapq.heappop(tree) right = _heapq.heappop(tree) root = (left[0] + right[0], left[1] + right[1], Tree(left[0] + right[0], left[1] + right[1])) root[2].left = left[2] root[2].right = right[2] _heapq.heappush(tree, root) return tree
def insert_num(self, num): """这里面记住最小值在0位""" if not self.left or num <= -self.left[0]: _heapq.heappush(self.left, -num) else: _heapq.heappush(self.right, num) if len(self.left) > len(self.right) + 1: tmp = -_heapq.heappop(self.left) _heapq.heappush(self.right, tmp) elif len(self.right) > len(self.left) + 1: tmp = -_heapq.heappop(self.right) _heapq.heappush(self.left, tmp)
def kthSmallest(self, root, k) -> int: heap = [] self.inorder_traversal( root, heap ) # get the elements in a list so that heap properties can be applied heapq.heapify(heap) # heapify to form a min heap (default) while k - 1: # pop k-1 elements so that the top element is the kth smallest one heappop(heap) k -= 1 return heap[0]
def _dictionary(self, dictfile, docfreq, k): """ This function reads the file which contains the token list and their frequency in the entire training corpus. Then it selects the top k tokens and generates the dictionary. Parameters ----------- dictfile: string path of file containing the tokens in training corpus and their frequencies. docfreq: string path of the file containing the term-document frequencies. This is needed to the tf-idf calculations. k: int dictionary size Note ----- this method creates an private variable self._vocab which contains the frequent tokens and an unique id associated with them and self._idf which stores the term frequency of each token in self._vocab """ temp_vocab = [] data = pickle.load(open(dictfile, "r")) df = pickle.load(open(docfreq,"r")) for line in data.keys(): # if the size of heap is smaller than k then add element if len(temp_vocab) <= k: heappush(temp_vocab, (int(data[line]), line)) else: #if the size of heap is greater than k then replace smallest element heapreplace(temp_vocab, (int(data[line]), line)) heappop(temp_vocab) # remove the extra element self._vocab = dict() itr = 0 self._idf = list() for term in list(temp_vocab): #convert heap into dictionary keyed on the token and value is token id self._vocab[term[1]] = itr #store the term-document frequency in case of tfidf calculations self._idf.append(df[term[1]]) itr += 1 self._idf = np.array(self._idf,dtype="float") self._idf = self._idf/1255353 #total number of documents is 1255353 self._idf = np.log(self._idf)
def pop_task(): while pq: priority, count, task = heappop(pq) if task is not REMOVED: del entry_finder[task] return task raise KeyError('pop form an empty prioriry queue')
def djikstra(nodes,links,source,dest): """An implementation of Djikstra's Algorithm for our Node and Link classes""" route = [] vertexes = [] for v in nodes: v.set_dist(float("inf")) v.set_prev(None) heappush(vertexes, v) source.set_dist(0) heapify(vertexes) while vertexes: unsorted = False u = heappop(vertexes) if u == dest: break #because we found the destination no need to look further for v in u.get_links(): if v.get_enabled(): alt = u.get_dist() + 1 target = v.get_target() if alt < target.get_dist(): target.set_dist(alt) target.set_prev(u) unsorted = True #just a variable that help check if changes were made to the objects inside the heap if unsorted: #because i updated the variables but the heap wasn't maintained, i just heapify it again heapify(vertexes) #this is the part that saves the distance and route if dest.get_dist() == float("inf"): #if there is no route then we just return None return None u = dest while u.get_prev() != None: v = u.get_prev() route.insert(0, v.get_specific_link(u)) u = v return route
def run(self): # First create the reporting times list reporting_times = numpy.arange(self.reportingInterval, self.timeHorizon, self.reportingInterval) prev_time = 0.0 # Iterate over the queue. The (delayed) events will be added to the queue as they are trigerred. for next_time in reporting_times: self.log.Message( "Simulating from {0:.5f}s to {1:.5f}s...".format( prev_time, next_time), 0) try: while True: # Get the first item from the heap (t_event, inlet_event_port, target_neurone) = heappop(self.events_heap) # If out of the interval put it back if t_event > next_time: heappush(self.events_heap, (t_event, inlet_event_port, target_neurone)) break #print('{0} --> {1}s (trigger event on {2})'.format(target_neurone.Name, t_event, inlet_event_port.CanonicalName)) # Integrate until next event time and report the data if there is a discontinuity target_neurone.simulation.IntegrateUntilTime( t_event, pyActivity.eDoNotStopAtDiscontinuity, True) # Trigger the event and reinitialize the system inlet_event_port.ReceiveEvent(t_event) target_neurone.simulation.Reinitialize() self.spike_count += 1 except IndexError: pass # Integrate each neurone until the *next_time* is reached and report the data for simulation in self.simulations: #print('{0}........ {1} {2} {3}'.format(simulation.m.Name, # simulation.CurrentTime, # '<' if simulation.CurrentTime < next_time else '=' , # next_time)) if simulation.CurrentTime < next_time: simulation.IntegrateUntilTime( next_time, pyActivity.eDoNotStopAtDiscontinuity, True) simulation.ReportData(next_time) # Set the progress self.log.SetProgress(100.0 * next_time / self.timeHorizon) prev_time = next_time print('Simulation has ended successfuly.') print('Processing the results...') # Finally, process the results (generate 2D plots, raster plots, and other voodoo-mojo stuff) self.processResults()
def leastInterval(self, tasks, n): """ :type tasks: List[str] :type n: int :rtype: int """ heap, m = [], collections.defaultdict(int) for t in tasks: m[t] += 1 res = 0 for k, v in m.iteritems(): heappush(heap, [-v, k]) while heap: temp = [] l = min(n + 1, len(heap)) for i in xrange(l): item = heappop(heap) item[0] = item[0] + 1 if item[0] <= 0: temp.append(item) if not temp: break res += len(temp) if temp[0][0] != 0: res += max(0, n + 1 - len(temp)) for t in temp: heappush(heap, t) return res
def find(self, origin, destination): frontier = [] heappush(frontier, (0, origin)) came_from = {origin: None} accumulated_cost = defaultdict(lambda: float('inf')) accumulated_cost[origin] = 0 while frontier: current = heappop(frontier)[1] if current == destination: break for next, base_cost in self.grid.neighbors(*current): calculated = self.cost(current, next) * base_cost if not calculated: continue new_cost = accumulated_cost[current] + calculated if new_cost < accumulated_cost[next]: accumulated_cost[next] = new_cost priority = new_cost + self.heuristic(next, destination) heappush(frontier, (priority, next)) came_from[next] = current current = destination yield current while current != origin: current = came_from[current] yield current
def solution(scoville, k): answer = 0 h = [] for i in scoville: _heapq.heappush(h, i) print(3**2) while h[0] < k: try: _heapq.heappush(h, _heapq.heappop(h) + (_heapq.heappop(h) * 2)) except Exception: return -1 answer += 1 return answer
def uniform_cost_search(startState, goalState, image): frontier = [] # lowest cost comes out first startState.cost = 0.0 startState.parent = None heappush(frontier, startState) beenthere = {startState : 0} width, height = image.size pixels = image.load() it = 0 while len(frontier) > 0: s = heappop(frontier) #Mystate if s == goalState: #return state which reached goal return s actions = options(s, width, height) if ((it % 5000) < 1000): pixels[s.x, s.y] = (0, 255, 0) it+=1 for a in actions: child = transition(s, a, pixels) # compute the next state acost = action_cost(s, a, pixels) # compute the cost of the action c_cost = beenthere.get(child) if c_cost != None: #if child is inside of beenthere if s.cost + acost < c_cost: child.cost = s.cost + acost child.parent = s; beenthere[child] = child.cost else: child.cost = s.cost + acost; child.parent = s; heappush(frontier, child) beenthere[child] = child.cost raise Exception("No path to traverse")
def dequeue(self): """Remove and return the lowest priority Item""" while self.pq: item = heappop(self.pq)[1] if item in self.entry_finder: del self.entry_finder[item] return item return None
def fa_cardio_scatter_plot(path): data_set = 'cardio' x_train, y_train = load_data(path + 'data/' + data_set + '/train/') pca = TruncatedSVD(n_components=5) pca_x_train = pca.fit_transform(x_train) kmeans = KMeans(n_clusters=10, random_state=0).fit(pca_x_train) print(kmeans.labels_) p = kmeans.predict(pca_x_train) for i in range(15): print(str(i) + " " + str(len(p[p == i]))) h = [] for i in range(15): heappush(h, (-1 * len(p[p == i]), i)) print(str(i) + " " + str(len(p[p == i]))) index = heappop(h)[1] plt.scatter(pca_x_train[:, 0][p == index].ravel(), pca_x_train[:, 1][p == index].ravel(), alpha=.1, color='red') index = heappop(h)[1] plt.scatter(pca_x_train[:, 0][p == index].ravel(), pca_x_train[:, 1][p == index].ravel(), alpha=.1, color='orange') index = heappop(h)[1] plt.scatter(pca_x_train[:, 0][p == index].ravel(), pca_x_train[:, 1][p == index].ravel(), alpha=.1, color='blue') index = heappop(h)[1] plt.scatter(pca_x_train[:, 0][p == index].ravel(), pca_x_train[:, 1][p == index].ravel(), alpha=.1, color='red') plt.xlabel('SVD Component 1') plt.ylabel('SVD Component 2') plt.title('Cardiovascular Data Representation after SVD') # plt.show() plt.savefig("plots/svd_cardio.png")
def check(self): if not self.call_times: return current_time = int(round(time.time() * 1000)) while self.call_times and self.call_times[0] <= current_time: call_time = heappop(self.call_times) for func in self.requests[call_time]: func() self.requests.pop(call_time)
def _handle_timeouts(self, timeout): if timeout > 0.0: time.sleep(timeout) current_time = time.time() while self._timeouts and (self._timeouts[0][0] <= current_time): item = heapq.heappop(self._timeouts)[1] item._handle_timeout(self)
def grp_cardio_scatter_plot(path): data_set = 'cardio' x_train, y_train = load_data(path + 'data/' + data_set + '/train/') grp = GaussianRandomProjection(n_components=3) grp_x_train = grp.fit_transform(x_train) kmeans = KMeans(n_clusters=10, random_state=0).fit(grp_x_train) print(kmeans.labels_) p = kmeans.predict(grp_x_train) p = kmeans.predict(grp_x_train) h = [] for i in range(15): heappush(h, (-1 * len(p[p == i]), i)) print(str(i) + " " + str(len(p[p == i]))) index = heappop(h)[1] plt.scatter(grp_x_train[:, 0][p == index].ravel(), grp_x_train[:, 1][p == index].ravel(), alpha=.1, color='yellow') index = heappop(h)[1] plt.scatter(grp_x_train[:, 0][p == index].ravel(), grp_x_train[:, 1][p == index].ravel(), alpha=.1, color='orange') index = heappop(h)[1] plt.scatter(grp_x_train[:, 0][p == index].ravel(), grp_x_train[:, 1][p == index].ravel(), alpha=.1, color='blue') index = heappop(h)[1] plt.scatter(grp_x_train[:, 0][p == index].ravel(), grp_x_train[:, 1][p == index].ravel(), alpha=.1, color='red') plt.xlabel('GRP Component 1') plt.ylabel('GRP Component 2') plt.title('Cardiovascular Data Representation after GRP') plt.savefig("plots/grp_cardio.png") print()
def heapsort(iterable): h = [] result = [] # 모든 원소를 차례대로 힙에 삽입 for value in iterable: _heapq.heappush(h, value) # 힙에 삽입된 모든 원소를 차례대로 꺼내어 담기 for i in range(len(h)): result.append(_heapq.heappop(h)) return result
def findKthLargest_1(self, nums, k): """ :type nums: List[int] :type k: int :rtype: int """ import _heapq if k > len(nums) + 1: return None if k == len(nums) + 1: return max(nums) heap_keep = [] for i in range(len(nums)): _heapq.heappush(heap_keep, nums[i]) if len(heap_keep) > k: _heapq.heappop(heap_keep) if len(heap_keep) < k: return -1 return _heapq.heappop(heap_keep)
def Idle(self): time_ms = time.monotonic() * 1000 while self._tasks_pq: entry = _heapq.heappop(self._tasks_pq) if entry[0] > time_ms: # Entry delay condition not met. Put back on queue and wait until next refresh cycle. _heapq.heappush(self._tasks_pq, entry) return task = entry[1] task()
def solution(v, k, l): # 방문 배열 만들어주고 # visted = [0] * (v + 1) # 출발 노드 방문 처리 # 최솟값 배열 minArray = [int(1e9)] * (v + 1) minArray[k] = 0 # 경로값 만들어 주고 # route = [[int(1e9) for _ in range(v + 1)] for _ in range(v + 1)] graph = [[] for _ in range(v + 1)] # 경로 바꿔 주기 -> 양쪽 모든 간선을 연결 해줘야 한다 for element in l: # route[element[0]][element[1]] = element[2] # route[element[1]][element[0]] = element[2] graph[element[0]].append((element[1], element[2])) # graph[element[1]].append((element[0], element[2])) // 단방향 그래프 ? q = [] # 최소힙 사용 시간복잡도 줄이기 # 힙푸시를 이용하기 0 = k로 가는 최소값 _heapq.heappush(q, (0, k)) # 큐가 있을때 while q: # dist = 비용 , now = 현재 노드 # 최단거리의 노드 끄내기, heapop 은 가장 작은 값이 출력된다. 비용이 dist, now = _heapq.heappop(q) # 방문된 노드라 라면 무시하기-> 이미 처리가 끝났슴 # if visted[now] == 1: # continue # 방문처리 # visted[now] = 1 # 지금 볼려는 곳이, 들어온 경로 보다 작으면 굳이 비교 할 필요가 없음, if minArray[now] < dist: continue # 현재 노드의 비용들을 돌아보면서 for cost in graph[now]: # 새로운 비용은 현재 거리랑, 최소 경로를 더해 주는데 newCost = dist + cost[1] # newCost = route[now][cost] + dist # 현재 노드를 거쳐서, 다른 노드로 이동하는 거리가 더 짧은 경우 if newCost < minArray[cost[0]]: minArray[cost[0]] = newCost _heapq.heappush(q, (newCost, cost[0])) # print(l) # print(route) # print(minArray) return minArray
def _duration_timeout(self): count = self._duration_timer.read() expire, task = heappop(self._expireq) task.stop() self._poller.unregister(task) task.close() if self._expireq: self._duration_timer.settime(self._expireq[0][0], 0.0, absolute=True) else: self._duration_timer.settime(0.0, 0.0) self._poller.unregister_fd(self._duration_timer.fileno())
def fastest_path_estimation(sol): """ Returns the time spent on the fastest path between the current vertex c and the ending vertex pm """ class Path: def __init__(self, places, graph): self.g = 0 # current cost self.graph = graph self.visited = [places[0]] # list of already visited attractions self.not_visited = copy.deepcopy(places[1:]) # list of attractions not yet visited def __lt__(self, other): return self.g < other.g def add(self, idx): # add the cost self.g += self.graph[self.visited[-1], idx] # add the to the visited place and remove from the unvisited places self.visited.append(idx) self.not_visited.remove(idx) def add_to_heap_queue(path): # custom function to add to heap queue sorted by the solution's cost heappush(h_queue, path) if len(sol.not_visited) == 0: return 0 elif len(sol.not_visited) == 1: return sol.graph[sol.visited[-1], sol.not_visited[0]] c = sol.visited[-1] pm = sol.not_visited[-1] # the heap queue of solution sorted by their cost - change all to tuples with g for dijkstra h_queue = [] # the places to use for the graph sub_search_places = [c] sub_search_places.extend(sol.not_visited) # push the first "node" in the queue add_to_heap_queue(Path(sub_search_places, sol.graph)) while True: # take the next solution with the shortest cost path = heappop(h_queue) # if it contains destination, stop and return that solution if pm in path.visited: return path.g # create a new solution for each neighbor of the current vertex and add it to heap queue for place in path.not_visited: new_path = copy.deepcopy(path) new_path.add(place) add_to_heap_queue(new_path)
def minMeetingRooms(self, intervals: list[list[int]]) -> int: if not intervals: return 0 intervals.sort() # End time free_rooms = [] heappush(free_rooms, intervals[0][1]) for i in intervals[1:]: # Here is i[start] time is less than the earlier finish time # for those meetings in heap # insert this in to heap if free_rooms[0] <= i[0]: heappop(free_rooms) heappush(free_rooms, i[1]) return len(free_rooms)
def start(self, script): self.inicio = Nodo(script) self.final = Nodo() lista_abierta = [] lista_cerrada = {} heappush(lista_abierta, self.inicio) while(lista_abierta): nodo_actual = heappop(lista_abierta) while(nodo_actual.g > len(script)): nodo_actual = heappop(lista_abierta) if(nodo_actual == self.final): print "Solucion Encontrada" self.lista_cerrada = lista_cerrada print 'Estados recorridos: '+str(len(lista_cerrada)) print 'Estados a visitar: '+str(len(lista_abierta)) print 'g: '+str(nodo_actual.g) print 'h: '+str(nodo_actual.h) return self.devolverRuta(nodo_actual) lista_cerrada[nodo_actual] = 'eliminado' for y in nodo_actual.gethijos(): if(not y in lista_cerrada): if(y.g <= len(script)): a = self.seek(lista_abierta,y) if (a == None): heappush(lista_abierta,y) elif(nodo_actual.g + 1 < y.g): a.g = y.g a.h = y.h a.f = y.f a.padre = y.padre a.script = y.script heapify(lista_abierta) return "Ha ocurrido un Error"
def run(self): # First create the reporting times list reporting_times = numpy.arange(self.reportingInterval, self.timeHorizon, self.reportingInterval) prev_time = 0.0 # Iterate over the queue. The (delayed) events will be added to the queue as they are trigerred. for next_time in reporting_times: self.log.Message("Simulating from {0:.5f}s to {1:.5f}s...".format(prev_time, next_time), 0) try: while True: # Get the first item from the heap (t_event, inlet_event_port, target_neurone) = heappop(self.events_heap) # If out of the interval put it back if t_event > next_time: heappush(self.events_heap, (t_event, inlet_event_port, target_neurone)) break #print('{0} --> {1}s (trigger event on {2})'.format(target_neurone.Name, t_event, inlet_event_port.CanonicalName)) # Integrate until next event time and report the data if there is a discontinuity target_neurone.simulation.IntegrateUntilTime(t_event, pyActivity.eDoNotStopAtDiscontinuity, True) # Trigger the event and reinitialize the system inlet_event_port.ReceiveEvent(t_event) target_neurone.simulation.Reinitialize() self.spike_count += 1 except IndexError: pass # Integrate each neurone until the *next_time* is reached and report the data for simulation in self.simulations: #print('{0}........ {1} {2} {3}'.format(simulation.m.Name, # simulation.CurrentTime, # '<' if simulation.CurrentTime < next_time else '=' , # next_time)) if simulation.CurrentTime < next_time: simulation.IntegrateUntilTime(next_time, pyActivity.eDoNotStopAtDiscontinuity, True) simulation.ReportData(next_time) # Set the progress self.log.SetProgress(100.0 * next_time / self.timeHorizon) prev_time = next_time print('Simulation has ended successfuly.') print('Processing the results...') # Finally, process the results (generate 2D plots, raster plots, and other voodoo-mojo stuff) self.processResults()
def grp_loan_distribution_plot(path): data_set = 'loan' x_train, y_train = load_data(path + 'data/' + data_set + '/train/') ica = GaussianRandomProjection(n_components=4) ica.fit_transform(x_train) ica_x_train = ica.transform(x_train) kmeans = KMeans(n_clusters=3, random_state=0).fit(x_train) print(kmeans.labels_) p = kmeans.predict(x_train) h = [] for i in range(15): heappush(h, (-1 * len(p[p == i]), i)) print(str(i) + " " + str(len(p[p == i]))) index_1 = heappop(h)[1] index_2 = heappop(h)[1] index_3 = heappop(h)[1] dist_1 = ica_x_train[:, 0][p == index_1].ravel() dist_2 = ica_x_train[:, 0][p == index_2].ravel() dist_3 = ica_x_train[:, 0][p == index_3].ravel() sns.distplot(dist_1, hist=False, rug=True, color='red') sns.distplot(dist_2, hist=False, rug=True, color='blue') sns.distplot(dist_3, hist=False, rug=True, color='orange') plt.title('Financial Loan GRP Distribution') plt.savefig('plots/loan_grp_distribution.png') print("") print(kurtosis(dist_1)) print(kurtosis(dist_2)) print(kurtosis(dist_3))
def scheduleCourse2(self, courses): """ :type courses: List[List[int]] :rtype: int """ heap, curTime, res = [], 0, 0 courses.sort(key=lambda c: c[1]) for k, v in enumerate(courses): curTime += v[0] heappush(heap, -v[0]) if curTime > v[1] and heap: # bugfixed need to check if heap is empty or not item = heappop(heap) curTime += item return len(heap)
def leastInterval(self, tasks, n): """ :type tasks: List[str] :type n: int :rtype: int """ heap, m = [], collections.defaultdict(int) for t in tasks: # got the frequency of the element, we could use `Counter` instead, more concise m[t] += 1 res = 0 for k, v in m.iteritems(): heappush(heap, [-v, k]) while heap: temp = [] # Example 1: # Input: tasks = ["A","A","A","B","B","B"], n = 2 # Output: 8 # Explanation: A -> B -> idle -> A -> B -> idle -> A -> B. # for this test case, n+1 = 3, len(heap) = 2, interval might > or < the task # l = min(n + 1, len(heap)) for i in xrange(l): # greedy, we firstly pick the most frequent element item = heappop(heap) # after choose one task, reduce the freq by 1, remember the freq is < 0 item[0] = item[0] + 1 if item[0] <= 0: temp.append(item) # if all tasks are already finshed( heap is empty) if not temp: break # how many tasks been put in temp, let's say [[A,0], [B,0]] res += len(temp) # for [[A,0], [B,0]], means we have already finised all tasks # also, it is possible have [[A,2], [B,0]..] if A task more than B # but no matter what, the front one would always be the most frequent task, if it becomes 0 # means no more task any more # but if we have [[A,1], [B,1]], n = 2, means we need an idle there, A, B, idle, so we need # n+1 - len(temp) if temp[0][0] != 0: res += max(0, n + 1 - len(temp)) # we need to push it back ,even for [A,0], [B,0] , then at next for loop, it would become +1 # and it would go to `if not temp: break`. for t in temp: heappush(heap, t) return res
def ica_loan_scatter_plot(path): data_set = 'loan' x_train, y_train = load_data(path + 'data/' + data_set + '/train/') ica = FastICA(n_components=2) ica.fit_transform(x_train) ica_x_train = ica.transform(x_train) kmeans = KMeans(n_clusters=10, random_state=0).fit(ica_x_train) print(kmeans.labels_) p = kmeans.predict(ica_x_train) for i in range(15): print(str(i) + " " + str(len(p[p==i]))) h = [] for i in range(15): heappush(h, (-1 * len(p[p==i]), i)) print(str(i) + " " + str(len(p[p==i]))) index = heappop(h)[1] plt.scatter(ica_x_train[:, 0][p==index].ravel(), ica_x_train[:,1][p==index].ravel(), alpha=.1, color='red') index = heappop(h)[1] plt.scatter(ica_x_train[:, 0][p==index].ravel(), ica_x_train[:,1][p==index].ravel(), alpha=.1, color='orange') index = heappop(h)[1] plt.scatter(ica_x_train[:, 0][p==index].ravel(), ica_x_train[:,1][p==index].ravel(), alpha=.1, color='blue') plt.xlabel('ICA Component 1') plt.ylabel('ICA Component 2') plt.title('Financial Loan Data Representation after ICA') # plt.show() plt.savefig("plots/ica_loan.png") print(x_train.shape)
def watershed(image, markers, connectivity=8, mask=None): """Return a matrix labeled using the watershed algorithm image - a two-dimensional matrix where the lowest value points are labeled first. markers - a two-dimensional matrix marking the basins with the values to be assigned in the label matrix. Zero means not a marker. connectivity - either 4 for four-connected or 8 (default) for eight- connected mask - don't label points in the mask """ if connectivity not in (4, 8): raise ValueError( "Connectivity was %d: it should be either four or eight" % (connectivity)) image = numpy.array(image) markers = numpy.array(markers) labels = markers.copy() max_x = markers.shape[0] max_y = markers.shape[1] if connectivity == 4: connect_increments = ((1, 0), (0, 1), (-1, 0), (0, -1)) else: connect_increments = ((1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)) pq, age = __heapify_markers(markers, image) # # The second step pops a value off of the queue, then labels and pushes # the neighbors # while len(pq): pix_value, pix_age, ignore, pix_x, pix_y = heappop(pq) pix_label = labels[pix_x, pix_y] for xi, yi in connect_increments: x = pix_x + xi y = pix_y + yi if x < 0 or y < 0 or x >= max_x or y >= max_y: continue if labels[x, y]: continue if mask != None and not mask[x, y]: continue # label the pixel labels[x, y] = pix_label # put the pixel onto the queue heappush(pq, (image[x, y], age, 0, x, y)) age += 1 return labels
def kSmallestSumPairs( self, arr1, arr2, k): # Return up to `k` smallest sum of pairs of `arr1` and `arr2` minHeap = [] for c in range(min(len(arr1), k)): heappush(minHeap, (arr1[c] + arr2[0], c, 0)) ans = [] while k > 0 and minHeap: _sum, c1, c2 = heappop(minHeap) ans.append(_sum) if c2 + 1 < len(arr2): heappush(minHeap, (arr1[c1] + arr2[c2 + 1], c1, c2 + 1)) k -= 1 return ans
def getPotentialFriends(self,userid,count): ''' used a min heap to get the top 'count' potential friends of a user. space complexity of min heap is O(count) insert into heap q and delete takes log(count) time printing the list in reverse order to get users with maximum count: complexity O(n) Overall runtime complexity is O(n) ''' if userid not in self.friendmap: print "User does not exist" return None minh = [] potentialfriends = [] for key,value in self.friendmap.iteritems(): if userid != key: if not self.areFriend(userid, key): c = self.getMutualFriendCount(userid,key) if len(minh) >= count: heappop(minh) heappush(minh,(c,key)) for friend in minh[::-1]: potentialfriends.append(friend[1]) return potentialfriends
def dijkstra_distance_between_experiences(self, id1, id2): exp_heap = Q.PriorityQueue() for id in range(len(self.experiences)): self.experiences[ id].time_from_current_s = self.DBL_MAX #DBL_MAX ??? exp_heap.put(self.experiences[id]) self.experiences[id1].time_from_current_s = 0 self.goal_path_final_exp_id = self.current_exp_id while not exp_heap.empty(): self.make_heap(Experience(exp_heap), len(exp_heap)) exp = Experience(exp_heap[0]) if (exp.time_from_current_s == self.DBL_MAX): return self.DBL_MAX heappop(exp_heap) for id in range(len(exp.links_from)): link = self.links[exp.links_from[id]] link_time_s = exp.time_from_current_s + link.delta_time_s if link_time_s < self.experiences[ link.exp_from_id].time_from_current_s: self.experiences[ link.exp_from_id].time_from_current_s = link_time_s self.experiences[link.exp_from_id].goal_to_current = exp.id for id in range(len(exp.links_from)): link = self.links[exp.links_from[id]] link_time_s = exp.time_from_current_s + link.delta_time_s if link_time_s < self.experiences[ link.exp_to_id].time_from_current_s: self.experiences[ link.exp_to_id].time_from_current_s = link_time_s self.experiences[link.exp_to_id].goal_to_current = exp_id if exp.id == id2: return exp.time_from_current_s return self.DBL_MAX
def watershed(image, markers, connectivity=8, mask=None): """Return a matrix labeled using the watershed algorithm image - a two-dimensional matrix where the lowest value points are labeled first. markers - a two-dimensional matrix marking the basins with the values to be assigned in the label matrix. Zero means not a marker. connectivity - either 4 for four-connected or 8 (default) for eight- connected mask - don't label points in the mask """ if connectivity not in (4,8): raise ValueError("Connectivity was %d: it should be either four or eight"%(connectivity)) image = numpy.array(image) markers = numpy.array(markers) labels = markers.copy() max_x = markers.shape[0] max_y = markers.shape[1] if connectivity == 4: connect_increments = ((1,0),(0,1),(-1,0),(0,-1)) else: connect_increments = ((1,0),(1,1),(0,1),(-1,1), (-1,0),(-1,-1),(0,-1),(1,-1)) pq,age = __heapify_markers(markers,image) # # The second step pops a value off of the queue, then labels and pushes # the neighbors # while len(pq): pix_value, pix_age, ignore,pix_x,pix_y = heappop(pq) pix_label = labels[pix_x,pix_y] for xi,yi in connect_increments: x = pix_x+xi y = pix_y+yi if x < 0 or y < 0 or x >= max_x or y >= max_y: continue if labels[x,y]: continue if mask != None and not mask[x,y]: continue # label the pixel labels[x,y] = pix_label # put the pixel onto the queue heappush(pq, (image[x,y],age,0,x,y)) age += 1 return labels
def start(self): if self._verbose: print'------------------------------- starting event handler -------------------------------' while len(self._queue) > 0 and self._finished_jobs < self.all_jobs: event = heappop(self._queue) if self._verbose: print SimulationTime.Instance().get_time(), '->', event.time, event forward_time = event.time - SimulationTime.Instance().get_time() SimulationTime.Instance().forward(forward_time) for core in self._cores: core.forward(forward_time) event.handle() self.check_candidates() if (not Logger.Instance().active) and self._finished_jobs >= self.warm_up: Logger.Instance().activate() if self._verbose: self.print_info() print ''
def greedyPath(points, start): gPath = [] # greedy path dist = [] # distance heap curr = start gPath.append(curr) # start path with start point while points: # while there are points left for i, point in enumerate(points): # get distances from current point to all other points heappush(dist, (distance(curr, point), i, point)) # 3-tuple [distance, point index, point coordinates] nearest = heappop(dist) # get nearest point dist = [] # clear heap del points[nearest[1]] # remove point from points curr = nearest[2] # update current point gPath.append(curr) # append point to greedyPath gPath.append(start) # return to start return gPath
def find_shortest_path(G, v): dist_so_far = {v: [0,[v]]} final_dist = {} heap=[] heappush(heap,(0,v)) while len(final_dist) < len(G) and len(heap) : value,w = heappop(heap) if w not in final_dist: final_dist[w] = dist_so_far[w] del dist_so_far[w] for x in G[w]: if x not in final_dist: path_len = G[w][x] if x not in dist_so_far: dist_so_far[x] = [] dist_so_far[x].append(final_dist[w][0] + path_len) dist_so_far[x].append(final_dist[w][1] + [x]) heappush(heap,(final_dist[w][0] + path_len, x)) elif final_dist[w][0] + path_len < dist_so_far[x][0]: dist_so_far[x][0] = final_dist[w][0] + path_len dist_so_far[x][1] = final_dist[w][1] + [x] heappush(heap,(final_dist[w][0] + path_len, x)) return final_dist
@author: Rahul ''' import heapq from _heapq import heappush, heappop if __name__ == '__main__': x = [1,0,3,5,2,0,1] minh = [] maxh = [] maxe = 0 equal = 0 for e in x: if equal == 0: heappush(minh,e) mine = heappop(minh) heappush(minh,mine) print mine equal = 1 else: heappush(minh,e) temp = heappop(minh) heappush(maxh,-temp) mine = heappop(minh) heappush(minh,mine) maxe = -1 * heappop(maxh) heappush(maxh,-maxe) median = float(maxe + mine) / 2 equal = 0 print median
# data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] # for item in data: # heappush(heap, item) # sort = [] # while heap: # sort.append(heappop(heap)) # print sort # import doctest # doctest.testmod() # test = [10] # if test < data: # print "sdf" # test = [0.1, 0.3, 0.5, 0.7, 0.9, 0.2, 0.4, 0.6, 0.8, 0.0] test = [ (0.1, [1, 5, 6]), (0.6, [9, 5, 6]) ] # tt = [[0.1, [4, 3,10,100]], [0.3, [5,5,1,23,23]], [0.5,3], [0.7, [1,5]], [0.7, [2,5]], [0.9, 1], [0.2, 4], [0.4, 10], [0.6,9], [0.8, 1], [0.0, 124]] heapify(test) print test # heapify(tt) heappush(test, (0.0, [1, 3])) print test dist, data = heappop(test) print dist, data # print tt # print pow(float(3), 2)
return map(itemgetter(2), result) # undecorate _nlargest = nlargest def nlargest(n, iterable, key=None): """Find the n largest elements in a dataset. Equivalent to: sorted(iterable, key=key, reverse=True)[:n] """ if key is None: it = izip(iterable, imap(neg, count())) # decorate result = _nlargest(n, it) return map(itemgetter(0), result) # undecorate in1, in2 = tee(iterable) it = izip(imap(key, in1), imap(neg, count()), in2) # decorate result = _nlargest(n, it) return map(itemgetter(2), result) # undecorate if __name__ == "__main__": # Simple sanity test heap = [] data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] for item in data: heappush(heap, item) sort = [] while heap: sort.append(heappop(heap)) print sort import doctest doctest.testmod()
def pop_node(data_structure, heap=False): return heappop(data_structure) if heap else data_structure.pop(0)
print a #双端队列 s = "yeah but no but yeah but no but yeah" words = s.split() wordlocations = defaultdict(list) for n, w in enumerate(words) : wordlocations[w].append(n) print wordlocations #堆 heap = range(1, 100) shuffle(heap) heapq.heapify(heap) print heap print heappop(heap) heappush(heap, 101) heapreplace(heap, 102) print heap #itertools for i in chain(range(1, 10), range(10, 20)) : print i #3个一组排列组合 for list in combinations(range(1,20), 3) : print list #从某个数开始,连续生产整数 for i in count(100) : if i == 200 :
def _slow_watershed(image, markers, connectivity=8, mask=None): """Return a matrix labeled using the watershed algorithm Use the `watershed` function for a faster execution. This pure Python function is solely for pedagogical purposes. Parameters ---------- image: 2-d ndarray of integers a two-dimensional matrix where the lowest value points are labeled first. markers: 2-d ndarray of integers a two-dimensional matrix marking the basins with the values to be assigned in the label matrix. Zero means not a marker. connectivity: {4, 8}, optional either 4 for four-connected or 8 (default) for eight-connected mask: 2-d ndarray of bools, optional don't label points in the mask Returns ------- out: ndarray A labeled matrix of the same type and shape as markers Notes ----- This function implements a watershed algorithm [1]_that apportions pixels into marked basins. The algorithm uses a priority queue to hold the pixels with the metric for the priority queue being pixel value, then the time of entry into the queue - this settles ties in favor of the closest marker. Some ideas taken from Soille, "Automated Basin Delineation from Digital Elevation Models Using Mathematical Morphology", Signal Processing 20 (1990) 171-182 The most important insight in the paper is that entry time onto the queue solves two problems: a pixel should be assigned to the neighbor with the largest gradient or, if there is no gradient, pixels on a plateau should be split between markers on opposite sides. This implementation converts all arguments to specific, lowest common denominator types, then passes these to a C algorithm. Markers can be determined manually, or automatically using for example the local minima of the gradient of the image, or the local maxima of the distance function to the background for separating overlapping objects. """ if connectivity not in (4, 8): raise ValueError("Connectivity was %d: it should be either \ four or eight" % (connectivity)) image = np.array(image) markers = np.array(markers) labels = markers.copy() max_x = markers.shape[0] max_y = markers.shape[1] if connectivity == 4: connect_increments = ((1, 0), (0, 1), (-1, 0), (0, -1)) else: connect_increments = ((1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)) pq, age = __heapify_markers(markers, image) pq = pq.tolist() # # The second step pops a value off of the queue, then labels and pushes # the neighbors # while len(pq): pix_value, pix_age, ignore, pix_x, pix_y = heappop(pq) pix_label = labels[pix_x, pix_y] for xi, yi in connect_increments: x = pix_x + xi y = pix_y + yi if x < 0 or y < 0 or x >= max_x or y >= max_y: continue if labels[x, y]: continue if mask is not None and not mask[x, y]: continue # label the pixel labels[x, y] = pix_label # put the pixel onto the queue heappush(pq, [image[x, y], age, 0, x, y]) age += 1 return labels
def pop(self): # Always return the least scored element return heappop(self.A)[1]
def pop(self): if self.size == 0: return None neg, pos = heappop(self.heap) self.size -= 1 return pos