class LazyQueue: def __init__(self): self._queue = PriorityQueue() def enq(self, item): self._queue.put(item) def deq(self): if self._queue.empty(): return None else: return self._queue.get() def __len__(self): return self._queue.qsize() def mget(self, n): if n > self._queue.qsize(): n = self._queue.qsize() lst = [] for _ in xrange(n): lst.append(self._queue.get()) return lst def extend(self, iterable): for ele in iterable: self.enq(ele) def append(self, item): self.enq(item)
class BHCAgenda(object): """ Maintain a priority queue for possible merges """ def __init__(self, sufficient_condition=None): if not sufficient_condition: self.sufficient_condition = lambda score: True else: self.sufficient_condition = sufficient_condition self.priority_queue = PriorityQueue() self.graveyard = set() def add_many(self, iterable): for item in iterable: pass def pop(self): score, (left_index, right_index) = self.priority_queue.get() # print "popped with score %2.5f" % score # either left or right index is in graveyard, then draw another # or score is not good enough # but no matter what, the queue size must be larger than 0 while ((left_index in self.graveyard or right_index in self.graveyard or not self.sufficient_condition(score)) and self.priority_queue.qsize() > 0): # print 'trying a second time. ' score, (left_index, right_index) = self.priority_queue.get() # print 'score this time: %2.5f' % score # avoiding queue errors if ( (left_index in self.graveyard or right_index in self.graveyard or not self.sufficient_condition(score)) and self.priority_queue.qsize() == 0): return 0,0,0 # bookkeep seen things self.graveyard.add(left_index) self.graveyard.add(right_index) return score, left_index, right_index def clear(self): self.priority_queue = PriorityQueue() self._put = self.strategy(self.priority_queue) self.graveyard = set() self.manifest = set() def push(self, score, left, right): """ The queue needs to have the score as the first item in the tuple This is how it orders the queue """ self.priority_queue.put((score, (left, right))) def __len__(self): return self.priority_queue.qsize()
def apply_idastar(self,start,goal,bound,debug=False): closedList = Set([]) openList = PriorityQueue() self.cameFrom = {} self.gScore = {} self.fScore = {} xstart = self.encode(start) xgoal = self.encode(goal) self.gScore[xstart] = 0 self.fScore[xstart] = self.heuristic_cost_estimate(start,goal) count = 1 openList.put((self.fScore[xstart],count,xstart)) while openList.qsize() > 0: fcurrent,other,xcurrent = openList.get() current = self.decode(xcurrent) if xcurrent == xgoal: return True,self.reconstruct_path(goal),openList.qsize()+len(closedList) closedList.add(xcurrent) neighbours = self.get_neighbours(current) next_bound = sys.maxsize for n in neighbours: xn = self.encode(n) if xn in closedList: continue tentative_gScore = self.get_gScore(xn) + 1 tentative_fScore = tentative_gScore + self.heuristic_cost_estimate(n,goal) if tentative_fScore > bound: if next_bound > tentative_fScore: next_bound = tentative_fScore continue neighbourInOpnedList = False for value,cnt,xitem in openList.queue: if xitem == xn: neighbourInOpnedList = True break if neighbourInOpnedList == False: openList.put((tempScore,count,xneighbour)) #If this is not a better path elif tentative_gScore >= self.get_gScore(xn): continue self.cameFrom[xn] = current self.gScore[xn] = tentative_gScore self.fScore[xn] = tentative_fScore return False,next_bound,len(closedList)+openList.qsize()
def plot_method_pairs_and_matrix(case_studies,fileappend=''): case_cov=np.cov(case_studies.transpose()) case_corr=np.corrcoef(case_studies.transpose()) cmatrix= case_corr fig = plt.figure(figsize=(twocol,twocol),dpi=figdpi,tight_layout=True) ax = fig.add_subplot(111) ppl.pcolormesh(fig,ax,cmatrix[inds][:,inds],#-np.diag([.99]*len(meths)), yticklabels=np.array(mindex)[inds].tolist(), xticklabels=np.array(mindex)[inds].tolist(), cmap=ppl.mpl.cm.RdBu,vmax=0.4,vmin= -0.4) ax.tick_params(axis='both', which='major', labelsize=8) plt.setp(ax.get_xticklabels(), rotation='vertical') cm=dark2 [l.set_color(cm[m_codes[mindex.index(l.get_text())]]) for i,l in enumerate(ax.get_yticklabels())] [l.set_color(cm[m_codes[mindex.index(l.get_text())]]) for i,l in enumerate(ax.get_xticklabels())] fig.show() fig.savefig(figure_path+('method_matrix%s.pdf'%fileappend)) #Show the highly correlated methods pq=PQ() pq_cross=PQ() for i in range(len(meths)): for j in range(i+1,len(meths)): m1text='(%s) %s'%(meths[i,1],meths[i,0]) m2text='(%s) %s'%(meths[j,1],meths[j,0]) pq.put((-cmatrix[i,j],(m1text,m2text))) if meths[i,1]!= meths[j,1]: pq_cross.put((-cmatrix[i,j],(m1text,m2text))) # Output the method correlations # Sets how many highly correlated methods should be displayed print_cap = 20 moutfile = open(results_path+('method_corrs%s.csv'%fileappend),'w') print 'All methods:' for i in range(pq.qsize()): v,(m1,m2)=pq.get() if i < print_cap: print '%.2f & %s & %s\\\\'%(-v,m1,m2) moutfile.write('%.9f | %s | %s\n'%(-v,m1,m2)) moutfile.close() moutfile = open(results_path+('method_corrs_cross%s.csv'%fileappend),'w') print 'Just cross methods:' for i in range(pq_cross.qsize()): v,(m1,m2)=pq_cross.get() if i < print_cap: print '%.2f & %s & %s\\\\'%(-v,m1,m2) moutfile.write('%.9f | %s | %s\n'%(-v,m1,m2)) moutfile.close()
def dijkstra(graph, source, target): """Dijkstra's shortest path algorithm""" queue = PriorityQueue() dist = {source: 0} prev = {} for vertex in graph: if vertex != source: dist[vertex] = float("inf") queue.put((dist[vertex], vertex)) while queue.qsize() != 0: u_dist, u = queue.get() u_node = graph[u] if u == target: break for v in u_node['linkTo']: alt = dist[u] + euclidean_dist(u_node['x'], u_node['y'], graph[v]['x'], graph[v]['y']) if alt < dist[v]: dist[v] = alt prev[v] = u queue.put((alt, v)) path = [] curr = target while curr in prev: path.append(curr) curr = prev[curr] path.append(source) return path[::-1]
class SendTaskQueue: def __init__(self): self.queue = PriorityQueue() def put_task(self, task): self.queue.put(task) @sms_exception def fetch_sms(self, count=100): msg_list = [] qsize = self.queue.qsize() for _ in range(qsize): task = self.queue.get() # task is instance of SimpleSendTask or CommonSendTask try: ms = task.fetch_sms(count) if len(ms) > 0: msg_list += ms count -= len(ms) if task.get_size() > 0: self.queue.put(task) except: log("SMS_SEND_TASK_FETCH_SMS_ERROR", content=task.__dict__, logger='sms', level='error') if not SendTaskClear.all_done(task.task): self.queue.put(task) if count <= 0: break return msg_list
class QueueBackend(QueueInterface): def __init__(self, unique=False, **kwargs): super(QueueInterface, self).__init__(**kwargs) self.queue_object = PriorityQueue() self.unique = unique self.unique_dict = {} def put(self, task, priority): if self.unique: key = unique_key(task) if key in self.unique_dict: return self.unique_dict[key] = True self.queue_object.put((priority, task)) def get(self, timeout): priority, task = self.queue_object.get(True, timeout) if self.unique: key = unique_key(task) del self.unique_dict[key] return task def size(self): return self.queue_object.qsize() def clear(self): try: while True: self.queue_object.get(False) except Empty: pass
class Astar: def __init__(self, start, goal, n): self.path = [] self. visited = [] self.priority_queue = PriorityQueue() self.start = start self.goal = goal self.n = n def solve(self): start_state = State(value=self.start, start=self.start, goal=self.goal, n=self.n) self.priority_queue.put((0, start_state)) while(not self.path and self.priority_queue.qsize()): closest_child = self.priority_queue.get()[1] closest_child.create_children() self.visited.append(closest_child.value) for child in closest_child.children: if child.value not in self.visited: # If child's value is equal to goal, solution is found if child.value == self.goal: self.path = child.path break self.priority_queue.put((child.cost, child)) if not self.path: print "Goal is unreachable. Terminating program." return self.path
def from_dict_to_prioqueue_urlset(dict,starting_url) : prioq = PriorityQueue() urlset = set() #first key is going to be the start url -> initiate with 0 distance (key) is_start_url = True for key in dict: urlset.add(key.lower()) if key.lower() == starting_url.lower() and is_start_url: key_tnode = TreeNode(0, key.lower()) prioq.put_nowait(key_tnode) prioq.queue.sort(key=attrgetter("key")) is_start_url = False else: key_tnode = TreeNode(float("inf"), key.lower()) prioq.put_nowait(key_tnode) # for each of the urls in its val, check if tnode already exists in circnode ring for val_url in dict[key]: urlset.add(val_url.lower()) # if it doesn't exist, add the tnode val_tnode = TreeNode(float("inf"), val_url.lower()) if not pq_member(prioq, val_url.lower()) : prioq.put_nowait(val_tnode) prioq.queue.sort(key=attrgetter("key")) key_tnode.neighbors.append(val_tnode) print "\tmin key: %g, url: %s" % ( prioq.queue[0].key, prioq.queue[0].self_url) print "\tsize of prioqueue: %d" % prioq.qsize() print "\tsize of dict: %d" % len(dict) return prioq, urlset
def mapper(): reader = csv.reader(sys.stdin, delimiter='\t') writer = csv.writer(sys.stdout, delimiter='\t', quotechar='"', quoting=csv.QUOTE_ALL) pq = PriorityQueue() topsize = 10 result = [] for line in reader: # YOUR CODE HERE post = line[4] if pq.qsize() < topsize: pq.put((len(post), line)) else: minpost = pq.get() if minpost[0] >= post[0]: pq.put((len(minpost), line)) else: pq.put((len(post), line)) for i in range(topsize): result.append(pq.get()) # writer.writerow(line) result.sort(key=lambda x: x[0]) for r in result: writer.writerow(r[1])
class AStarSolver(object): """docstring for AStarSolver""" def __init__(self, start, goal): self.path = [] self.visited_queue = [] self.priority_queue = PriorityQueue() self.start = start self.goal = goal def solve(self): start_state = StateString( self.start, 0, self.start, self.goal ) self.priority_queue.put((0,start_state)) while not self.path and self.priority_queue.qsize(): closest_child = self.priority_queue.get()[1] closest_child.create_children() self.visited_queue.append(closest_child.value) for child in closest_child.children: if child.value not in self.visited_queue: if not child.dist: self.path = child.path break self.priority_queue.put((child.dist, child)) if not self.path: print "Could not reach the goal: " + self.goal return self.path
def main(): global CREATURE_COUNT if process_command_line(): c0 = [] c1 = PriorityQueue() print "[+]\tLoading DB..." # load in creatures from DB lc = load_DB() # f = open('database', 'a') # f.close() # f = open('database') # lc = f.read() # f.close() loaded_creatures = lc.split("\n") # finish loading print "[+]\tSuccess" print "[+]\tCreating initial batch of creatures..." cl = create_creatures(CREATURE_COUNT, GENOME_LENGTH, tools) generation = 0 for i in cl: c1.put((100, i)) for i in loaded_creatures: c1.put((50, Creature(0, i))) for ii in range(0, GENE_POOL_INFLUENCE - 1): c1.put((50, Creature(0, mutate(i)))) print "[+]\tSuccess" # print '[+]\tPre-breeeding in loaded creatures with the population' +\ # ' for great success' # while not c1.empty(): # c = c1.get()[1] # c0.append(c) # c1 = breed_it(c0) # c1 = c0 print "[+]\tSuccess" exploit_found = 0 while exploit_found == 0: generation += 1 CREATURE_COUNT = c1.qsize() print "[>]\tRunning with creature_count %d,\tgeneration %d" % (CREATURE_COUNT, generation) c2 = PriorityQueue(0) cached_c = 0 total_c = 0 while not c1.empty(): c = c1.get()[1] total_c += 1 if c.modified == 0: cached_c += 1 if fitnessfunction(c) == 1: exploit_found = 1 break c2.put((c.score, c)) # print '[i]\tEfficiency %s, cached[%d], total[%d]' %\ # (str((total_c-cached_c) * 1.0 / total_c),cached_c,total_c) c3 = cull_it(c2) c4 = [] while not c3.empty(): c = c3.get()[1] c4.append(c) c1 = breed_it(c4) print "[i]\tExploit found in %d seconds with %d requests" % (abs(int(start_time - time.time())), REQ_TOTAL)
def generate_policy(self,end,reduced_map=None): if not reduced_map: reduced_map = self.default_graph h,w = len(reduced_map),len(reduced_map[0]) DIRS = [-1,0],[0,1],[1,0],[0,-1] distances = [[sys.maxint] * w for _ in range(h)] directions = [[-1] * w for _ in range(h)] distances = PriorityQueue() distances.put((0,end)) visited = set() todo = {} while(not distances.empty()): if not distances.qsize() % (h*w/5): print "{0} nodes visited".format(len(visited)) min_dist,min_node = distances.get() if min_node not in visited: for i,direction in enumerate(DIRS): candidate = (min_node[0] + direction[0],min_node[1] + direction[1]) if candidate[0] >= 0 and candidate[0] < h and candidate[1] >=0 and candidate[1] < w and candidate not in visited and not reduced_map[candidate[0]][candidate[1]]: if candidate not in todo or min_dist + 1 < todo[candidate]: distances.put((min_dist + 1,candidate)) todo[candidate] = min_dist + 1 directions[candidate[0]][candidate[1]] = DIRS[(i+2)%4] visited.add(min_node) return directions
class AStar_Solver: def __init__(self, start, goal): ''' Store the start and goal of program, and set up vars ''' self.path = [] self.visitedQueue = [] self.priorityQueue = PriorityQueue() self.start = start self.goal = goal def Solve(self): ''' Create start state, then organize children based on value and check children of highest value child ''' startState = State_String(self.start, 0, self.start, self.goal) count = 0 self.priorityQueue.put((0, count, startState)) while(not self.path and self.priorityQueue.qsize()): closestChild = self.priorityQueue.get()[2] closestChild.CreateChildren() self.visitedQueue.append(closestChild.value) for child in closestChild.children: if child.value not in self.visitedQueue: count += 1 if not child.dist: self.path = child.path break self.priorityQueue.put((child.dist, count, child)) if not self.path: print ("Goal of " + self.goal + " is not possible!") return self.path
class BreakpointSolver: """Solver that finds the smallest amount of generations needed to get from one fruit fly to one with a different genome""" def __init__(self, start, goal): self.path = [] self.unique_mutations_checked = [] self.priority_queue = PriorityQueue() self.start = start self.goal = goal self.moved_genes = 0 def solve(self): fruit_fly = FruitFlyMutation(self.start, 0, self.start, self.goal) count = 0 self.priority_queue.put((0, count, fruit_fly)) while (not self.path and self.priority_queue.qsize()): closest_child = self.priority_queue.get()[2] closest_child.create_children() self.unique_mutations_checked.append(closest_child.genome) for child in closest_child.children: if child.genome not in self.unique_mutations_checked: count +=1 if child.genome == self.goal: self.path = child.path self.moved_genes = child.moved_genes break self.priority_queue.put((child.generation, count,child)) if not self.path: print ("Goal of ", self.goal, " is not possible for this starting genome!") return self
def create_huffman_tree(word_counts): """Make a huffman tree from a dictionary containing word counts. This method creates a binary huffman tree, that is required for :class:`BinaryHierarchicalSoftmax`. For example, ``{0: 8, 1: 5, 2: 6, 3: 4}`` is converted to ``((3, 1), (2, 0))``. Args: word_counts (``dict`` of ``int`` key and ``int`` or ``float`` values.): Dictionary representing counts of words. Returns: Binary huffman tree with tuples and keys of ``word_coutns``. """ if len(word_counts) == 0: raise ValueError('Empty vocabulary') q = PriorityQueue() for w, c in word_counts.iteritems(): q.put((c, w)) while q.qsize() >= 2: (count1, word1) = q.get() (count2, word2) = q.get() count = count1 + count2 tree = (word1, word2) q.put((count, tree)) return q.get()[1]
def run(self): """ basically calculate the shortest path with A* search algorithm """ origin = Node(self.startPose) #PriorityQueue of nodes pq = PriorityQueue() currentNode = origin # Compute the AStar search algorithm while not currentNode.pos.equals(self.goalPose) and not rospy.is_shutdown(): children = self.expandNode(currentNode) for node in children: pq.put((node.cost(), node)) #it is ranked by the cost if(pq.qsize() == 0): #no more nodes to be expanded print "didn't find a path" currentNode = origin break # pop the "closest" node to the goal currentNode = pq.get()[1] self.calcPathWayPoints(currentNode) #lastNode
def crossOver(self): """ Fill in the rest of the population by 'mating' pairs of chromosomes """ # calculate fitness scores self.calculateFitness() # create an empty priority queue for the new generation newGeneration = PriorityQueue() # keep going until we've got a full population while self.generation.qsize() + newGeneration.qsize() < self.populationSize: # get a chromosome chromosome1 = self.generation.get() # get a second chromosome if not self.generation.empty(): chromosome2 = self.generation.get() else: break # copy the chromosome copy1 = copy.deepcopy(chromosome1) copy2 = copy.deepcopy(chromosome2) # mutate the copies copy1.crossOver(copy2) # put the chromosomes in the new generation newGeneration.put(chromosome1) newGeneration.put(chromosome2) newGeneration.put(copy1) newGeneration.put(copy2) # keep the new generation while not newGeneration.empty(): chromosome = newGeneration.get() self.generation.put(chromosome)
class AStarSolver: def __init__(self,start, goal): self.path = [] self.visited_queue = [] self.priority_queue = PriorityQueue() self.start = start self.goal = goal def solve(self): start_state = StateString(self.start, 0, self.start, self.goal) count = 0 self.priority_queue.put(0, count, start_state) while not self.path and self.priority_queue.qsize(): closest_child = self.priority_queue.get()[2] closest_child.create_children() self.visited_queue.append(closest_child.value) for child in closest_child.children: if child.value not in self.visited_queue: count += 1 if not child.dist: self.path = child.path break self.priority_queue.put(child.dist, count) if not self.path: print "Goal of {0} is not possible!".format(self.goal) return self.path
def ucs(wam, start, goal): pQueue = PriorityQueue() vertices = set() # Start node has a priority of 0 pQueue.put((0, start)) while pQueue.qsize() > 0: path = pQueue.get() node = path[-1][-1] vertices.add(node) if node == goal: path = str(path) path = [item for sublist in path for item in sublist if ord(item) >=\ 65 and ord(item) <= 90] return path # Get connected nodes. for localNode in wam[node]: if not localNode in vertices: new_path = list(path) new_path.append(localNode) # Append node(s) with priority of final node. priority = wam[node][localNode] # Flatten the path. pQueue.put((priority, new_path)) return "Search failed."
def dikstra(self, start): """Return shortest path according to Dikstra's algorithm""" # Find the node with the start value: start_node = self._get_node(start) start_node.distance = 0 # Create priority queue dpq = PriorityQueue() dpq.put((start_node.distance, start_node)) while dpq.qsize() > 0: curr = dpq.get()[1] curr.visited = True for neighb in self._neighbors(curr.value): if not neighb.visited: alt = (curr.distance + self.weight_edge(curr.value, neighb.value)) if alt < neighb.distance: neighb.distance = alt neighb.previous = curr dpq.put((neighb.distance, neighb)) # Create list of shortest path from start to final shortest = [start] while curr.value != start: shortest.insert(1, curr.value) curr = curr.previous return shortest
class AStar_Solver: def __init__(self,start,goal): self.path = [] self.visitedQueue = [] self.priorityQueue = PriorityQueue() self.start = start self.goal = goal def Solve(self): startState = State_String(self.start,0,self.start,self.goal) count = 0 self.priorityQueue.put((0,count,startState)) while(not self.path and self.priorityQueue.qsize()): closestChild = self.priorityQueue.get()[2] closestChild.CreateChildren() self.visitedQueue.append(closestChild.value) for child in closestChild.children: if child.value not in self.visitedQueue: count +=1 if child.value == self.goal: self.path = child.path break self.priorityQueue.put((child.dist,count,child)) if not self.path: print "Goal of ", self.goal, " is not possible for this starting genome!" return self.path
def getLocalOutlierFactors(vects, k): #TMP HACK return [0]*len(vects) pairDist = getPairwiseDist(vects) #The list of neighbor ids for each point neighbors = [None for x in range(len(vects))] #Populate each of these lists with the k nearest neighbors for i in range(len(vects)): pq = PriorityQueue() for j in range(len(vects)): if(i != j): pq.put((-pairDist[i][j], j)) if(pq.qsize() > k): pq.get() neighbors[i] = [neighborId for (negDist, neighborId) in pq.queue] #print("neighbors " + str(neighbors)) #For each point, the distance to its kth nearest neighbor kDist = [0] * len(vects) for i in range(len(vects)): for j in neighbors[i]: kDist[i] = max(kDist[i], pairDist[i][j]) #print("kdist " + str(kDist)) #local reachability density - the inverse of the average reachability distance to all of my neighbors lrd = [0] * len(vects) for i in range(len(vects)): #first compute the sum for j in neighbors[i]: lrd[i] += max(kDist[j], pairDist[i][j]) #normalize and invert in one step lrd[i] = k / lrd[i] #print("lrd " + str(lrd)) #local outlier factor - average ratio of neighbor densities to my density lof = [0] * len(vects) for i in range(len(vects)): #first compute the sum for j in neighbors[i]: lof[i] += lrd[j] #normalize and divide by my density lof[i] = lof[i] / (k*lrd[i]) #print("lof " + str(lof)) return lof
class ChartAgenda(object): CKY_STRATEGY = "CKY" def __init__(self, strategy): """ Put strategies into here. Add their name as a constant Add their function as class function """ strategy_options = {self.CKY_STRATEGY:ChartAgenda._shortest_str_strategy} self.strategy = strategy_options[strategy] self.settings = config.ChartSettings.default() self.priority_queue = PriorityQueue() self._put = self.strategy(self.priority_queue) self.graveyard = set() self.manifest = set() @staticmethod def _shortest_str_strategy(priority_queue): def put(item): priority_queue.put((len(item), item)) return put def _existence_check(self, item): gravecheck = item in self.graveyard manifestcheck = item in self.manifest return manifestcheck or gravecheck def _length_check(self, item): if self.settings.aggressively_prune: if item.boundaries[1] > self.settings.utter_len: return False return True def add_many(self, iterable): for item in iterable: if not self._existence_check(item): self._put(item) self.manifest.add(item) def add(self, item): if not self._existence_check(item) and self._length_check(item): self._put(item) self.manifest.add(item) def pop(self): edge_len, edge = self.priority_queue.get() self.manifest.remove(edge) self.graveyard.add(edge) return edge def clear(self): self.priority_queue = PriorityQueue() self._put = self.strategy(self.priority_queue) self.graveyard = set() self.manifest = set() def __len__(self): return self.priority_queue.qsize()
def find_nearest_neighbors(origin_node, num_neighbors, on_forward_graph=True): # maintain set of boundary nodes that have been visited by this search visited_nodes_cost = {} origin_node.cost = 0 # Initialize Dijkstra queue with the origin node nodes_to_search = PriorityQueue() nodes_to_search.put((0, origin_node)) expanded_count = 0 max_pq_size = 0 while(not nodes_to_search.empty()): # Get the nearest node from the priority queue max_pq_size = max(nodes_to_search.qsize(), max_pq_size) (cost, node) = nodes_to_search.get() expanded_count += 1 visited_nodes_cost[node] = cost if(len(visited_nodes_cost) >= num_neighbors): break connecting_links = None if on_forward_graph: connecting_links = node.backward_links else: connecting_links = node.forward_links # Propagate to neighbors on the forward graph using the backward links for connecting_link in connecting_links: neighbor = None if on_forward_graph: neighbor = connecting_link.origin_node else: neighbor = connecting_link.connecting_node proposed_cost = node.cost + connecting_link.time if(proposed_cost < neighbor.cost): neighbor.cost = proposed_cost nodes_to_search.put((proposed_cost, neighbor)) #cleanup for node in visited_nodes_cost: node.cost = float('inf') for (cost,node) in nodes_to_search.queue: node.cost = float('inf') # Now, all origin nodes (and some other nodes) all know their distance from # the given origin_node return visited_nodes_cost
def compute_pr_cluster_indices(ordering, boundary, n_clusters, compute_thick_part, min_thick=0.0001): def find_split(C, boundary): best_pr = sys.float_info.max index = -1 for i in range(1, len(C) - 2): if (boundary[C[i - 1]] >= boundary[C[i]] and boundary[C[i]] <= boundary[C[i + 1]]): thick_width = compute_thick_part(boundary, C, i) pr = boundary[C[i]] / max(thick_width, min_thick) if pr < best_pr: best_pr = pr index = i return best_pr, index + 1 pinch_ratios = [] queue = PriorityQueue() C = range(len(ordering)) pr, idx = find_split(C, boundary) queue.put((pr, idx, C)) pinch_ratios.append(pr) while queue.qsize() < n_clusters: q, t, C_i = queue.get() if t < 0: # no split loc break C_j, C_k = C_i[:t], C_i[t:] pr1, idx1 = find_split(C_j, boundary) pr2, idx2 = find_split(C_k, boundary) pinch_ratios.append(pr1) pinch_ratios.append(pr2) queue.put((pr1, idx1, C_j)) queue.put((pr2, idx2, C_k)) cluster_indices, n_actual_clusters = [], 0 for i in range(min(queue.qsize(), n_clusters)): q, t, C_i = queue.get() if C_i: cluster_indices.append(C_i) n_actual_clusters += 1 pinch_ratios = sorted(pinch_ratios)[:n_actual_clusters - 1] return pinch_ratios, cluster_indices
def mergeKLists(self, lists): dummy = ListNode(None) curr = dummy q = PriorityQueue() for node in lists: if node: q.put((node.val,node)) while q.qsize()>0: curr.next = q.get()[1] curr=curr.next if curr.next: q.put((curr.next.val, curr.next)) return dummy.next
def solve(ropes): if len(ropes) <= 1: return 0 min_heap = PriorityQueue() for i in ropes: min_heap.put(i) total = 0 while min_heap.qsize() > 1: cost = min_heap.get() + min_heap.get() total += cost min_heap.put(cost) return total
def buildHuffmanTree(strlen, charFreqList): pq = PriorityQueue() for key, value in charFreqList.iteritems(): pq.put((float(value) / float(strlen), HuffmanNode(key, float(value) / float(strlen)))) while pq.qsize() > 2: x,y,z = pq.get(), pq.get(), pq.get() pq.put((x[0] + y[0] + z[0], HuffmanNode(None, x[0] + y[0] +z [0], x[1], y[1], z[1]))) return pq.get()[1]
def median_maintenance(num_stream): q_left = PriorityQueue() q_right = PriorityQueue() first = num_stream[0] second = num_stream[1] if first <= second: q_left.put(-first) q_right.put(second) else: q_left.put(-second) q_right.put(first) for num in num_stream[2:]: if num <= -q_left.queue[0]: q_left.put(-num) else: q_right.put(num) if abs(q_right.qsize() - q_left.qsize()) > 1: if q_left.qsize() > q_right.qsize(): q_right.put(-q_left.get()) else: q_left.put(-q_right.get()) return -q_left.queue[0], q_right.queue[0]
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ n = len(lists) q = PriorityQueue(maxsize=n) dummy = ListNode(None) cur = dummy for node in lists: if node: q.put((node.val, node)) while q.qsize() > 0: temp = q.get() cur.next = temp[1] cur = cur.next if cur.next: q.put((cur.next.val, cur.next)) return dummy.next
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ from Queue import PriorityQueue vhead = ListNode(-1) curr = vhead q = PriorityQueue() for l in lists: if l: q.put((l.val, l)) while q.qsize() > 0: curr.next = q.get()[1] curr = curr.next if curr.next: q.put((curr.next.val, curr.next)) return vhead.next
def kthSmallest1(self, matrix, k): ''' 优先队列 ''' q = PriorityQueue() n = len(matrix) limit = n * n - k + 1 for i in matrix: for k in i: if q.qsize() == limit: tmp = q.get() if tmp < k: q.put(k) else: q.put(tmp) else: q.put(k) return q.get()
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ from Queue import PriorityQueue dummy = ListNode(None) curr = dummy q = PriorityQueue() for node in lists: if node: q.put((node.val, node)) while q.qsize() > 0: curr.next = q.get()[1] # always get the min node curr = curr.next if curr.next: q.put((curr.next.val, curr.next)) return dummy.next
def _build_trie(self, frequency): """ Build a binary trie and return its root node """ nodes = PriorityQueue() for char, freq in frequency.iteritems(): if freq > 0: nodes.put(self.Node(char, freq)) # merge two smallest tries while nodes.qsize() > 1: left = nodes.get() right = nodes.get() parent = self.Node(0, left.frequency + right.frequency, left, right) nodes.put(parent) # return the root node return nodes.get()
def createHuffmanTree(weightDictionary): uniqueID = 0 Q = PriorityQueue() for key, weight in weightDictionary.items(): node = Node(weight, key, None, None) Q.put((weight, uniqueID, node)) uniqueID += 1 while Q.qsize() > 1: tup1 = Q.get() tup2 = Q.get() weight = tup1[0] + tup2[0] node = Node(weight, '_', tup1[2], tup2[2]) Q.put((weight, uniqueID, node)) uniqueID += 1 return Q.get()[2]
class CrawlerPQueue(PriorityQueue): def __init__(self): self.pq = PriorityQueue(-1) def qsize(self): return self.pq.qsize() def empty(self): return self.pq.empty() def full(self): return self.pq.full() def put(self, item): self.pq.put(item) def get(self): return self.pq.get()
class QueueBackend(QueueInterface): def __init__(self, spider_name, **kwargs): super(QueueBackend, self).__init__(spider_name, **kwargs) self.queue_object = PriorityQueue() self.schedule_list = [] def put(self, task, priority, schedule_time=None): if schedule_time is None: self.queue_object.put((priority, task)) else: self.schedule_list.append((schedule_time, task)) def get(self): now = datetime.utcnow() removed_indexes = [] index = 0 for schedule_time, task in self.schedule_list: if schedule_time <= now: self.put(task, 1) removed_indexes.append(index) index += 1 self.schedule_list = [ x for idx, x in enumerate(self.schedule_list) if idx not in removed_indexes ] _, task = self.queue_object.get(block=False) return task def size(self): return self.queue_object.qsize() + len(self.schedule_list) def clear(self): try: while True: self.queue_object.get(False) except Empty: pass self.schedule_list = [] def close(self): pass
class PressureControlQueue(object): __shared_state = {} def __init__(self, frequency_time): # self.__dict__ = self.__shared_state self._lock = threading.Lock() self._qsize_lock = threading.Lock() self._queue_lock = threading.Lock() self.tick_time = time.time() self.frequency_time = frequency_time self.link_priority_queue = PriorityQueue() self.qsize = 0 def get(self): with self._lock: while True: current = time.time() if self._has_pending_site_until(current): link_job = self.pop_link() return link_job time.sleep(0.2) def statics(self): with self._queue_lock: return "links queue size : %d" % self.link_priority_queue.qsize() def pop_link(self): link_job = self.link_priority_queue.get(True, 3) with self._qsize_lock: self.qsize -= 1 return link_job def put_link(self, link_job): with self._queue_lock: self.tick_time += self.frequency_time link_job.tick_time = self.tick_time self.link_priority_queue.put(link_job) with self._qsize_lock: self.qsize += 1 def _has_pending_site_until(self, current): if self.link_priority_queue.empty(): return False return current >= self.link_priority_queue.queue[0].tick_time
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ dummy = ListNode(0) cur = dummy q = PriorityQueue() for node in lists: if node: q.put((node.val, node)) while q.qsize() > 0: node = q.get()[1] cur.next = node cur = cur.next if cur.next: q.put((cur.next.val, cur.next)) return dummy.next
def dij(m): L = len(m) C = len(m[0]) pq = PriorityQueue() pq.put((1, (0, 0))) visit = set() while pq.qsize() > 0: (dist, (l, c)) = pq.get() if (l, c) == (L - 1, C - 1): return dist if (l, c) in visit: continue visit.add((l, c)) for (ml, mc) in moves: nextPos = (l + ml, c + mc) if availablePos(nextPos, m): pq.put((dist + 1, nextPos)) return 500
def bfs_search(state, dfs_route): stateQueue = PriorityQueue() if fit_regular(state) == False: return None new_state = copy.deepcopy(state) new_state.sol_matrix = np.where(new_state.sol_matrix > 0, True, False) if checkSolution(new_state): return new_state stateQueue.put((len((np.where(state.isfilled_matrix == False))[0]), state)) while not stateQueue.empty(): notfilled_num, state = stateQueue.get() row_branch = None for row_positons in dfs_route: if False in state.isfilled_matrix[row_positons[1]]: state.isfilled_matrix[row_positons[1]] = True row_branch = row_positons break if row_branch == None: continue for row in row_branch[2]: new_state = copy.deepcopy(state) new_state.sol_matrix[row_branch[1]] = row if fit_regular(new_state) == True: notfilled_num = len( (np.where(new_state.isfilled_matrix == False))[0]) if settings.DEBUGG: print notfilled_num, " size: ", stateQueue.qsize() if notfilled_num == 0: new_state.sol_matrix = np.where(new_state.sol_matrix > 0, True, False) if checkSolution(new_state): del stateQueue return new_state else: # print new_state.sol_matrix if settings.DEBUGG: print "error" del new_state continue stateQueue.put((notfilled_num, new_state)) return None
def topKFrequent(self, nums, k): frequent = dict() for i in nums: frequent.setdefault(i, 0) frequent[i] += 1 q = PriorityQueue() for num, cnt in frequent.items(): if q.qsize() == k: val, key = q.get() if cnt > val: q.put((cnt, num)) else: q.put((val, key)) else: q.put((cnt, num)) res = list() for i in q.queue: res.append(i[1]) return res
def topKFrequent(self, nums, k): freqs = dict() for i in nums: freqs.setdefault(i, 0) freqs[i] += 1 q = PriorityQueue() for k1, v in freqs.items(): if q.qsize() == k: val, key = q.get() if v > val: q.put((v, k1)) else: q.put((val, key)) else: q.put((v, k1)) res = list() for i in q.queue: res.append(i[1]) return res
def PQ(food, snake, key): queue = PriorityQueue() queue.put((heuristic(snake, food), [snake, [key]])) visited = set() visited.add(tuple([l for k in snake for l in k])) f.write("queue: " + str(queue) + "\n") while (queue.empty() == False): state = queue.get() if (state[1][0][0] == food): return state[1][1][1:] moves = getMoves(food, state[1][0]) f.write(str(queue.qsize()) + "\n") for m in moves: temp = tuple([l for k in m[0] for l in k]) if temp not in visited: m[1] = state[1][1] + m[1] queue.put((heuristic(m[0], food), m)) visited.add(temp) return [27]
def solve(self): ID = 0 startTime = time() currNode = Node(self.init_state) #self.printP() if self.checkSolvable(currNode.puzzle) == False: return ["UNSOLVABLE"] # 2 Data Structures to keep track of... openList = PriorityQueue() openList.put((currNode.getH(), currNode)) # STABLEST costMap = {currNode.key:0} steps = 0 #Nodes popped off frontier while True: steps += 1 ## if steps % 100000 == 0: ## print 'step:', steps, 'size', openList.qsize() ## sys.stdout.flush() if openList.empty(): #Empty frontier print 'Empty Queue!' break currNode = openList.get()[1] # STABLEST if self.isGoalState(currNode.puzzle): ans = self.reconstruct(currNode) self.timeTaken = time() - startTime self.nodesPopped = steps self.nodesInside = openList.qsize() self.finalMoves = len(ans) ## print 'TIME:', self.timeTaken ## print 'nodesPopped', self.nodesPopped return ans for child in currNode.getChildren(currNode): ID += 1 child.g = currNode.g + 1 #Child is now a Node if child.key not in costMap or child.g < costMap[child.key]: costMap[child.key] = child.g child.h = child.getH() #ONLINE child.tick = ID openList.put((child.g + child.h, child)) # STABLEST timeTaken = time() - startTime print 'Time taken:', str(timeTaken) return ["UNSOLVABLE"]
class MaxQueue(object): ''' A priority queue sorted in descending order instead of ascending order If maxlength > 0, queue keeps only the maxlength entries with highest values not memory efficient in python since small memory is not reused # reduce length to maxlength if queue is too long if self.maxlength > 0 and len(self) > self.maxlength + self.length_tol: with self.decrease_length: print 'Reducing length of MaxQueue by removing values less than', print 'Used memory before = ', self.memory_mon.usage() new_pq = PriorityQueue() for i in range(self.maxlength - 1): new_pq.put(self.pq.get()) print -self.pq.get()[0], 'from consideration' self.pq = new_pq print 'Used memory after = ', self.memory_mon.usage() ''' def __init__(self, maxlength=0, length_tol=1000): self.pq = PriorityQueue() self.decrease_length = multiprocessing.Lock() self.maxlength = maxlength self.length_tol = length_tol def put(self, tup): # add new item to queue self.pq.put((-tup[0], tup[1])) def get(self, block=True): tup = self.pq.get(block) return (-tup[0], tup[1]) def get_nowait(self): tup = self.pq.get_nowait() return (-tup[0], tup[1]) def __len__(self): return self.pq.qsize() def empty(self): return self.pq.empty()
def minMeetingRooms(intervals): from Queue import PriorityQueue if not intervals: return 0 else: q = PriorityQueue() for i in range(len(intervals)): q.put([intervals[i][0], i, 'start']) maxRoom = 0 currentRoom = 0 while q.qsize() > 0: time, idx, status = q.get() if status == 'start': currentRoom += 1 maxRoom = max(maxRoom, currentRoom) q.put([intervals[idx][1], idx, 'end']) else: currentRoom -= 1 return maxRoom
def getRequest(self): with self.condition: LOG.info("getRequest condition acquired") requestPQ = None while ((requestPQ == None) and (not self.isDestroying)): if PriorityQueue.qsize(self) > 0: _, requestPQ = PriorityQueue.get(self) else: self.condition.wait() LOG.info("isDestroying=%s" % self.isDestroying) requestDB = None if (not self.isDestroying): LOG.info("idRecord %s" % (requestPQ["idRecord"])) idRecord = requestPQ["idRecord"] requestDB = self.__getDB(idRecord) requestDB.update(requestPQ) self.condition.notifyAll() request = requestDB LOG.info("getPQ condition released") return request
def minMeetingRooms(self, intervals): """ :type intervals: List[Interval] :rtype: int """ from Queue import PriorityQueue # O(nlgn) Q = PriorityQueue() intervals.sort(key=lambda itm: itm.start) for i, interval in enumerate(intervals): if Q.empty(): Q.put(interval.end) else: head = Q.get() if head <= interval.start: Q.put(interval.end) else: Q.put(interval.end) Q.put(head) return Q.qsize()
def preProcess(edgeweights,sdist,qvalues): N = traci.junction.getIDCount() #no. of junctions print("no. of nodes: ",N) '''write djikstra''' pq = PriorityQueue() for i in range(N): pq.put((0,i)) sdist[i][i] = 0 while pq.qsize() > 0: top = pq.get() #print("top: ",top) u = top[1] for j in range(N): if edgeweights[u][j] > 0 and sdist[i][u]+edgeweights[u][j] < sdist[i][j]: sdist[i][j] = sdist[i][u] + edgeweights[u][j] pq.put((sdist[i][j],j)) sdist[i][i] = Parameters.inf print(pd.DataFrame(sdist)) return
def getLeastNumbers(self, arr, k): """ :type arr: List[int] :type k: int :rtype: List[int] """ if k <= 0 or (not arr) or len(arr) == 0: return [] Q = PriorityQueue() for x in arr: Q.put(-x) while Q.qsize() > k: Q.get() ans = [] while not Q.empty(): ans.append(-Q.get()) return ans
def merge_k_sorted_linkedlists(lists): from Queue import PriorityQueue newhead = ListNode(0) current = newhead q = PriorityQueue() # putting the headnodes of each list # to the q is the same as putting # the whole list there, because we are # dealing with LINKED list here. for headnode in lists: if headnode: q.put((headnode.val, headnode)) while q.qsize() > 0: current.next = q.get()[1] # index [1] to get the actual node current = current.next # move the new position in the new list # while we are at it, # we put the current's next node to q if current.next: q.put((current.next.val, current.next)) return newhead.next
class queue: def __init__(self): self.list_queue = PriorityQueue() def push(self, node): self.list_queue.put(node) def distance(self, pt1, pt2): return np.sqrt((pt2[0] - pt1[0]) * (pt2[0] - pt1[0]) + (pt2[1] - pt1[1]) * (pt2[1] - pt1[1])) def pop(self): node = self.list_queue.get() return node def leng(self): return self.list_queue.qsize() def isfull(self): return np.invert(self.list_queue.empty())
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ dump = ListNode(0) queue = PriorityQueue() for item in lists: while item is not None: queue.put(item.val) item = item.next node = dump while queue.qsize() > 0: data = queue.get() while node.next: node = node.next node.next = ListNode(data) return dump.next
def rec_for_a_cus(cus_id, num_rec=3): from Queue import PriorityQueue from rspy.db import db_rs q = PriorityQueue() rates = db_rs.read_rate(CID = cus_id) goods_dict = db_rs.get_goods_dict(reverse=True) for record in rates: if record['REAL'] == 0: q.put(Movie(record['GID'], goods_dict[record['GID']], record['RATE'])) temp = "" if not q.empty(): s = q.qsize() for i in xrange(num_rec if num_rec < s else s): temp += "\n"+q.get().__str__() print temp[1:len(temp)] else: print '' print 'There is no such customer!'
def chargingChaos(f): soln = '' cases = int(f.readline()) for case in xrange(cases): row = f.readline().split(' ') N = int(row[0]) L = int(row[1]) # Tracer()() current = sorted(f.readline().strip().split(' ')) required = sorted(f.readline().strip().split(' ')) # Tracer()() states = PriorityQueue() states.put((0, current, 0)) visited = set({}) visited.add(' '.join(current)) found = False sol = 0 while not states.qsize() == 0: topstr = states.get() top = topstr[1] steps = topstr[2] # Tracer()() if len([1 for x,y in zip(required, top) if not x==y]) == 0: found = True sol = steps break; for i in xrange(L): if i >= L: Tracer()() nextstate = flipper(top, i) # Tracer()() if not ' '.join(nextstate) in visited: visited.add(' '.join(nextstate)) states.put((steps+1, nextstate, steps+1)) # print states.qsize() # Tracer()() if not found: steps = "NOT POSSIBLE" soln += 'Case #{0}: {1}\n'.format(case+1, steps) # print soln return soln
def topKFrequent(self, words, k): """ :type words: List[str] :type k: int :rtype: List[str] """ mapping = {} for word in words: if word not in mapping: mapping[word] = Word(word) else: mapping[word].freq += 1 pq = PriorityQueue() for word in mapping: pq.put(mapping[word]) if pq.qsize() > k: pq.get() res = [None for _ in range(k)] for i in range(k - 1, -1, -1): res[i] = pq.get().word return res
def create_tree(freq): p = PriorityQueue() for f in freq: p.put(f) while p.qsize() > 1: l, r = p.get(), p.get() node = None dat = "" if isinstance(l[1], Node): dat += l[1].data else: dat += l[1] if isinstance(r[1], Node): dat += r[1].data else: dat += r[1] node = Node(l, r, dat) p.put((l[0] + r[0], node)) return p.get()
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ if lists is None: return None if len(lists) == 0: return [] cur = ListNode() newHead = cur q = PriorityQueue() for node in lists: if node: q.put((node.val, node)) while q.qsize() > 0: cur.next = q.get()[1] cur = cur.next if cur.next: q.put((cur.next.val, cur.next)) return newHead.next