Пример #1
0
def schedule(tasks, num_processors):
	_cpy_list = [t for t in tasks]
	total_slice = 0
	for i in tasks:
		total_slice += i
	_cpy = total_slice
	pq = PriorityQueue()
	temp_out_list = [0]*len(tasks)
	for i in range(len(tasks)):
		pq.put((1.0 / tasks[i], i))
	iterations = 0
	misses = 0
	while pq.empty() == False:
		temp_out_c = 0
		for i in range(num_processors):
			if pq.empty() == True:
				break
			else:
				temp_out_list[temp_out_c] = pq.get()[1]
				temp_out_c += 1
		for i in range(temp_out_c):
			tasks[temp_out_list[i]] -= 1
			if tasks[temp_out_list[i]] != 0:
				pq.put(((_cpy_list[temp_out_list[i]] - tasks[temp_out_list[i]]) * _cpy / _cpy_list[temp_out_list[i]], temp_out_list[i]))
		iterations += 1
		#print iterations
		for i in range(len(tasks)):
			lag = 1.0 * _cpy_list[i] * iterations / _cpy - (_cpy_list[i] - tasks[i])
			if lag > 0:
				misses += math.floor(lag)
	return misses
Пример #2
0
def get_matches(vector, num_matches):
  best_matches = PriorityQueue(num_matches)
  good_matches = PriorityQueue(num_matches)
  ok_matches = PriorityQueue(num_matches)


  matches_found = 0
  vectors = get_vectors()
  for v in vectors:
    r = sim_coeff(vector, v)
    print(r)
    if r<.5:
      print("not a match")
      continue
    if r<.7:
      print("Ok Match Found")
      ok_matches.put((r, v))
      matches_found += 1
      print(v)
      if matches_found == num_matches:
        break
      else:
        continue
    if r<.9:
      print("Good Match Found")
      good_matches.put((r, v))
      matches_found += 1
      print(v)
      if matches_found == num_matches:
        break
      else:
        continue
    if r<=1:
      print("Great Match Found")
      best_matches.put((r, v))
      if not ok_matches.empty():
        ok_matches.get()
      else:
        matches_found += 1
      print(v)
      if matches_found == num_matches:
        break
      else:
        continue
    if r>1:
      print("Esthena is bad at math.")
      
  pq = PriorityQueue()
  while not best_matches.empty():
    pq.put(best_matches.get())
  while not good_matches.empty():
    pq.put(good_matches.get())
  while not (ok_matches.empty()):
    pq.put(ok_matches.get())
  print("Results: ")
  matches = []
  while not pq.empty():
    matches.append(pq.get()[1])
  return matches
Пример #3
0
class WorkersList(object):
	"""docstring for WorkersList"""
	def __init__(self):
		super(WorkersList, self).__init__()
		self.queue = PriorityQueue()
		self.workers = []

	def empty_queue(self):
		while not self.queue.empty():
			next_level = self.queue.get()
			print 'Processing level:', next_level.schedule

	def get_from_queue(self):
		return self.queue.get()

	def queue_size(self):
		return self.queue.size()

	def _collect_workers(self):
		while not self.queue.empty():
			next_job = self.queue.get()
			worker = Worker(next_job, next_job.description)
			self.workers.append(worker)
			worker.start()

	def start(self):
		self._collect_workers()
		for worker in self.workers:
			worker.join()

	def put_in_queue(self, job):
		self.queue.put(job)

	def stop_single_worker(self, value):
		for worker in self.workers:
			if worker.name == value:
				worker.triggerStop = False
				break
		else:
			raise WorkerException("Worker with name/id {}".format(value))

	def stop_all_workers(self):
		for worker in self.workers:
			worker.triggerStop = False

	def terminate_all_workers(self):
		for worker in workers:
			worker.terminate()

	def terminate_single_worker(self, value):
		for worker in self.workers:
			if worker.name == value:
				worker.terminate()
				break
		else:
			raise WorkerException("Worker with name/id {}".format(value))
def search_schedule(plant):
    # todo AI scheduling alg can base on this: heat priorities in q, caster priorities
    # todo put index to the heats, delete heat+1, group+1
    # todo AI: find a fastest schedule, then cal the adjustment room in time, then shift the EAF tasks
    # todo AI: exchange the groups orders, see what happens with the final ECost
    # todo aim for a ChemE journal paper
    # currently, heat/group starting at 1, time starting at 0
    """Find a feasible schedule by matching heats and equipment units.

    Main Idea:
        Match available heats (intermediate products) to available equipment units.
        Maintain availability by priority queues (priority index: available time).
    """
    schedule = []
    q_t_h = PriorityQueue()   # ready time (priority), heat
    for heat in range(1, plant.num_heats+1):
        q_t_h.put((0, heat))
    for stage in [1, 2, 3]:
        q_t_u = PriorityQueue()     # ready time (priority), unit
        for unit, num in plant.stage2units[str(stage)].items():
            for u_id in range(num):
                q_t_u.put((0, unit, u_id))
        q_t_h_next = PriorityQueue()    # ready time of heat for next stage
        while not q_t_h.empty():
            t_heat, heat = q_t_h.get()
            t_unit, unit, u_id = q_t_u.get()
            t_start = max(t_heat, t_unit)
            task = plant.tasks[unit][heat-1]
            t_end_process = t_start + plant.task_duration[task]
            q_t_u.put((t_end_process, unit, u_id))
            # todo, RTN2
            transport = plant.tasks['TR_S%d' % stage][heat-1]
            t_end_trans = t_end_process + plant.task_duration[transport]
            q_t_h_next.put((t_end_trans, heat))
            schedule.append((stage, heat, unit, u_id, task, t_start, t_end_process, t_end_process))
            schedule.append((stage, heat, 'TR_S%d' % stage, 0, transport, t_end_process, t_end_trans, t_end_trans))
        q_t_h = q_t_h_next
    heat2time = dict()
    while not q_t_h.empty():
        t, heat = q_t_h.get()
        heat2time[heat] = t
    q_t_caster = PriorityQueue()     # ready time (priority), unit
    for unit, num in plant.stage2units['4'].items():
        for u_id in range(num):
            q_t_caster.put((0, unit, u_id))
    for group in range(1, plant.num_groups+1):
        t_caster, caster, caster_id = q_t_caster.get()
        t_group = max([heat2time[heat] - plant.heat_consume_time_in_group[caster][heat]
                       for heat in plant.group2heats[str(group)]])
        t_start = max(t_group, t_caster)
        task = plant.tasks[caster][group-1]
        t_end_process = t_start + plant.task_duration[task]
        t_cleanup = t_start + plant.task_cleanup_duration[task]
        schedule.append((4, group, caster, caster_id, task, t_start, t_end_process, t_cleanup))
        q_t_caster.put((t_cleanup, caster, caster_id))
    return schedule
Пример #5
0
def get_matches(vector, num_matches):
  best_matches = PriorityQueue(num_matches)
  good_matches = PriorityQueue(num_matches)
  ok_matches = PriorityQueue(num_matches)


  matches_found = 0
  vectors = get_vectors()
  for v in vectors:
    r = sim_coeff(vector, v)
    print(r)
    if r<.5:
      print("not a match")
      continue
    if r<.7:
      print("Ok Match Found")
      ok_matches.put(v, r)
      matches_found += 1
      print(v)
      if matches_found == num_matches:
        break
      else:
        continue
    if r<.9:
      print("Good Match Found")
      good_matches.put(v, r)
      matches_found += 1
      print(v)
      if matches_found == num_matches:
        break
      else:
        continue
    if r<=1:
      print("Great Match Found")
      best_matches.put(v, r)
      matches_found += 1
      print(v)
      if matches_found == num_matches:
        break
      else:
        continue
    if r>1:
      print("Esthena is bad at math.")
      
  print("Ok: ")
  while not ok_matches.empty():
    print(ok_matches.get())
  print("Good: ")
  while not good_matches.empty():
    print(good_matches.get())
  print("Best: ")
  while not best_matches.empty():
    print(best_matches.get())
Пример #6
0
def solve(N, L, start, goal):
    """search for minimum bit switches to make start == goal
    NB: treat goal and start as sets of currents -- that is, order doesn't
    matter in comparing start to goal and all currents in start/goal
    are mutually unique"""
    # BFS w/ priority queue; queue orders by min bits flipped;
    # we don't use an 'explored' set because we may need to revisit the same
    # configuration of currents several times as index i increments;
    # instead, to constrain the search space, we use the is_consistent filter
    # before placing a state in the queue in order to check that the
    # configuration of currents in that state is consistent with goal at least
    # up to bit i-1
    start_state = (0, start, 0)  # ( n_bits_flipped, state_of_currents, index )
    queue = PriorityQueue()
    queue.put( start_state )

    while not queue.empty():
        nchanges, state, index = queue.get()

        if is_goal(state, goal):
            return nchanges

        for nch,s,i in successors(nchanges, state, index):
            if is_consistent(s, goal, i):
                # when i = len(goal)+1, s will be added to queue
                # only if s == goal
                queue.put([nch, s, i])

    return 'NOT POSSIBLE'
Пример #7
0
 def req_proxy(self, url):
     from urlparse import urlparse
     netloc = urlparse(url).netloc
     busy_queue = PriorityQueue()
     lazy_queue = PriorityQueue()
     index = 0
     now = datetime.utcnow()
     while index < self.proxy_in_queue_count():
         index += 1
         proxy_url = self.get_proxy_from_queue()
         if not proxy_url:
             break
         if proxy_url in self.proxy_meta_map:
             proxy_meta = self.proxy_meta_map[proxy_url]
             if proxy_meta.last_used_time and (now - proxy_meta.last_used_time).total_seconds() < self.settings["interval_second"]:
                 busy_queue.put_nowait((proxy_meta.last_used_time, proxy_url))
                 continue
             if netloc in proxy_meta.latency and proxy_meta.latency[netloc][0] >= self.settings["max_unavailable_count"]:
                 import random
                 if random.randint(1, 10) > 1:
                     lazy_queue.put_nowait((proxy_meta.latency[netloc], proxy_url))
                     continue
             proxy_meta.last_used_time = now
             proxy_meta.master = netloc
             return proxy_meta.proxy
     while not lazy_queue.empty():
         _, proxy_url = lazy_queue.get_nowait()
         if proxy_url in self.proxy_meta_map:
             proxy_meta = self.proxy_meta_map[proxy_url]
             proxy_meta.last_used_time = now
             proxy_meta.master = netloc
             return proxy_meta.proxy
     return None
Пример #8
0
 def a_star(self):
     # like BFS, but puts coords with lowest heuristic (path length + manhattan dist to goal) up front
     pq = PriorityQueue(maxsize=0)
     pq.put_nowait((self.manhattan_distance(self.currPos, self.goalPos), (self.currPos, [])))
     visited = set()
     bestPath = None
     bestHeur = None
     numNodes = 0
     while not pq.empty():
         priority, curr = pq.get_nowait()
         coord, path = curr
         visited.add(coord)
         if bestPath is not None and priority >= bestHeur:
             pass
         elif self.getChar(coord) == '%': # wall
             pass
         else: # recursive case
             if self.getChar(coord) == '.': # goal
                 print "Found a path:", path
                 if bestPath is None or len(path) < len(bestPath):
                     print "Is best path"
                     bestPath = path[:]
                     bestHeur = priority
             for adj, direction in self.adjacent(coord):
                 if adj not in visited and self.getChar(adj) != '%':
                     numNodes += 1
                     heur = len(path + direction) + self.manhattan_distance(adj, self.goalPos)
                     if bestPath is None or heur < bestHeur: # preselect based on heuristic
                         pq.put_nowait((heur, (adj, path + direction)))
     print "Num Nodes:", numNodes
     print self.debug(bestPath) # debug
     return bestPath
Пример #9
0
	def dijkstra(self, adjacencies, start_point, end_point):
		seen_so_far = defaultdict(float)
		for k in adjacencies:
			seen_so_far[k] = float('inf')

		q = PriorityQueue()
		start = Vertex(start_point, [], 0.0)
		q.put(start)
		seen_so_far[start_point] = 0

		while not q.empty():
			v = q.get()
			if v.coords == end_point:
				new_path = v.path
				new_path.append(end_point)

				# write to file
				with open("output", "w") as out_file:
					for point in new_path:
						out_file.write('{} {}\n'.format(point[0], point[1]))
				self.best_path = [(new_path[i], new_path[i+1]) for i in range(len(new_path)-1)]
				return
			for point in adjacencies[v.coords]:
				# import pdb; pdb.set_trace()
				new_cost = v.cost+distance(v.coords, point)
				if seen_so_far[point]<new_cost:
					continue
				seen_so_far[point]=new_cost
				new_path = deepcopy(v.path)
				new_path.append(v.coords)
				q.put(Vertex(point, new_path, new_cost))
Пример #10
0
def ucs(source, target, graph):
    """ Uniform-cost graph search """
    queue = PriorityQueue() # fringe
    queue.put((0, source))

    parent = {source:None}
    visited = {}

    while not queue.empty():
        (d, v_in) = queue.get()

        if v_in not in visited or d < visited[v_in]:

            if v_in == target:
                return (d, build_path(parent, target))

            for v_out in graph.adj(v_in):
                cost = graph.distance(v_in, v_out) + d
                if v_out not in visited:
                    queue.put((cost, v_out))
                    parent[v_out] = v_in

            visited[v_in] = cost

    return None
Пример #11
0
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)
Пример #12
0
def segment(img) :
	g = numpy.array(img.getdata())
	g = g.reshape(img.size)
	gx = g[:-1,1:] - g[:-1,:-1]
	gy = g[1:,:-1] - g[:-1,:-1]
	gms = gx * gx + gy * gy

	seg = Image.new('L', gms.shape)
	taken = numpy.zeros(seg.size)
	#print 'original local mininum'
	for i in range(seg.size[0]) :
		for j in range(seg.size[1]) :
			if localmin(gms, i, j) :
				taken[i][j] = 1
				seg.putpixel((j, i), img.getpixel((j, i)))
				#print (j, i), img.getpixel((j, i))
	q = PriorityQueue(-1)
	#print 'expand'
	for i in range(seg.size[0]) :
		for j in range(seg.size[1]) :
			if taken[i][j] > 0 :
				addNeighbor(seg, gms, taken, i, j, q)
	#print q.qsize()
	while not q.empty() :
		(i, j) = q.get()[1]
		addNeighbor(seg, gms, taken, i, j, q)
		#print q.qsize()
	return seg
Пример #13
0
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)
Пример #14
0
 def a_star_penalize(self, forwardPenalty, turnPenalty):
     # part 1.2
     # using euclidean heuristic (not manhattan)
     pq = PriorityQueue(maxsize=0)
     pq.put_nowait((self.manhattan_distance(self.currPos, self.goalPos), (self.currPos, [])))
     visited = set()
     bestPath = None
     bestHeur = None
     numNodes = 0
     while not pq.empty():
         priority, curr = pq.get_nowait()
         coord, path = curr
         visited.add(coord)
         if bestPath is not None and priority >= bestHeur:
             pass
         elif self.getChar(coord) == '%': # wall
             pass
         else: # recursive case
             if self.getChar(coord) == '.': # goal
                 print "Found a path:", path
                 if bestPath is None or len(path) < len(bestPath):
                     bestPath = path[:]
             for adj, direction in self.adjacent(coord):
                 if adj not in visited and self.getChar(adj) != '%':
                     numNodes += 1
                     heur = self.calculate_penalty(path + direction, forwardPenalty, turnPenalty) + self.manhattan_distance(adj, self.goalPos) * forwardPenalty
                     if bestPath is None or heur < bestHeur: # preselect based on heuristic
                         pq.put_nowait((heur, (adj, path + direction)))
     print "Num Nodes:", numNodes
     print self.debug(bestPath) # debug
     return bestPath
Пример #15
0
def Astar(start, goal, cost_matrix, strategy='minimize'):
    mindist = min([min(dists.values()) for c, dists in cost_matrix.items()])
    maxdist = max([max(dists.values()) for c, dists in cost_matrix.items()])
    def cost_fn(path):
        if strategy == 'minimize':
            return path_cost(path, cost_matrix) + (len(cost_matrix.keys()) - len(path)) * 2 * mindist
        else:
            return -(path_cost(path, cost_matrix) + (len(cost_matrix.keys()) - len(path)) * 2 * maxdist)
    abort_cost = 1 << 32
    q = PriorityQueue()
    q.put((cost_fn([start]), [start]))
    best_path = []
    while not q.empty():
        total_cost, partial_path = q.get()
        if total_cost > abort_cost:
            break
        if partial_path[-1] == goal and len(partial_path) == len(cost_matrix.keys()):
            if total_cost < abort_cost:
                abort_cost = total_cost
                best_path = partial_path
        else:
            for c in cost_matrix[partial_path[-1]]:
                if c not in partial_path:
                    new_path = partial_path + [c]
                    total_cost = cost_fn(new_path)
                    if total_cost < abort_cost:
                        q.put((total_cost, new_path))
    return best_path
Пример #16
0
	def calculatePathToPoint(self, start, goal):
		# http://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode
		closedSet = set()
		queue = PriorityQueue(0)
		queue.put((self._heuristic(start, goal), start))
		cameFrom = {}
		score = {}

		score[start] = 0

		while not queue.empty():
			_, current = queue.get()
			if current.x == goal.x and current.y == goal.y:
				return self._reconstructPath(cameFrom, goal)

			if current.flatten(800) in closedSet:
				continue
			closedSet.add(current.flatten(800))
			for neighbor in self._getNeighborNodes(current):
				if neighbor.flatten(800) in closedSet:
					continue

				turnPenalty = 0.5

				if current.flatten(800) in cameFrom and \
				current.x - neighbor.x == cameFrom[current.flatten(800)].x - current.x and \
				current.y - neighbor.y == cameFrom[current.flatten(800)].y - current.y:
					turnPenalty = 0 

				neighborScore = score[current] + 1 + turnPenalty
				cameFrom[neighbor.flatten(800)] = current
				score[neighbor] = neighborScore
				queue.put((neighborScore + self._heuristic(neighbor, goal), neighbor))

		return []
Пример #17
0
 def trapRainWater(self, board):
     """
     :type board: List[List[int]]
     :rtype: int
     """
     m = len(board)
     if m == 0: return 0
     n = len(board[0])
     queue = PriorityQueue()
     visited = [[False] * n for _ in range(m)]
     for i in range(m):
         visited[i][0] = True
         queue.put((board[i][0], i, 0))
         visited[i][n-1] = True
         queue.put((board[i][n-1], i, n-1))
     for j in range(n):
         visited[0][j] = True
         queue.put((board[0][j], 0, j))
         visited[m-1][j] = True
         queue.put((board[m-1][j], m-1, j))
     dirs = [(-1,0),(1,0),(0,-1),(0,1)]
     res = 0
     while not queue.empty():
         h, i, j = queue.get()
         for di, dj in dirs:
             ni, nj = i+di, j+dj
             if ni >= 0 and ni < m and nj >= 0 and nj < n and not visited[ni][nj]:
                 visited[ni][nj] = True
                 res += max(0, h - board[ni][nj])
                 queue.put((max(h, board[ni][nj]), ni, nj))
     return res
Пример #18
0
def astar(source, target, graph, heuristic=null_heuristic):
    """ A* algorithm """
    queue = PriorityQueue()
    queue.put((0, source))
    
    parent = {source:None}
    visited = {}

    while not queue.empty():
        (d, v_in) = queue.get()

        if v_in not in visited or d < visited[v_in]:

            if v_in == target:
                return (d, build_path(parent, target))

            for v_out in graph.adj(v_in):
                cost = graph.distance(v_in, v_out) + d
                fn = cost + heuristic(v_out, graph) # only diference in retion to UCS
                if v_out not in visited:
                    queue.put((fn, v_out))
                    parent[v_out] = v_in

            visited[v_in] = cost

    return None
Пример #19
0
def run(graph,start,goal):

    frontier = PriorityQueue()
    frontier.put((0,start))
    came_from = {}
    came_from[start] = None
    cost_so_far = {}
    cost_so_far[start] = 0

    while not frontier.empty():
        current = frontier.get()[1]

        if current == goal:
            break

        for nextNode in graph.neighbors(current):
            new_cost = cost_so_far[current] + graph.cost(current,nextNode)
            if nextNode not in cost_so_far or new_cost < cost_so_far[nextNode]:
                frontier.put((new_cost,nextNode))
                cost_so_far[nextNode] = new_cost;
                came_from[nextNode] = current

    #for x in came_from:
    #    print (x,came_from[x],),
    print len(came_from)

    current = goal
    path = [current]
    while current != start:
        current = came_from[current]
        path.append(current)
    print path
Пример #20
0
    def a_star(self, start, goal):
        """"""
        # Init priority queue.
        q = PriorityQueue()
        q.put(start, 0)

        came_from = {start: None}
        # The known cost needed to travel from start to a point.
        visited = {start: 0}

        while not q.empty():
            # pop the point with lowest priority(cost).
            # The idea is always that points tends to be closer to goal first.
            p = q.get()

            if p == goal:
                # Reach the goal.
                self.reconstruct_path(came_from, goal)
                return

            for neighbor in self.neighbors(p):
                tentative = visited[p] + self.heuristic(p, neighbor)

                if neighbor not in visited or tentative < visited[neighbor]:
                    came_from[neighbor] = p
                    visited[neighbor] = tentative

                    # Priority is the estimated cost that it took to travel from
                    # neighbor to goal. In this case, it's just the Manhattan
                    # distance assuming that there are no obstacles between them.
                    priority = tentative + self.heuristic(neighbor, goal)
                    q.put(neighbor, priority)
Пример #21
0
def aStar(initialState, heuristic):
    #stores a list of visited coords, the direction and whether the tile was affected by demolish
    visited = []
    fringe = PriorityQueue()

    #add the start node to the fringe
    fringe.put((-(initialState.score - heuristic(initialState)), initialState))

    while True:

        if fringe.empty():
            print "No Solution"
            return None

        nextState = fringe.get()[1]

        #check if the tile has been affected by demolish
        if len(nextState.actionList) > 0 and nextState.actionList[-1] is nextState.act_demolish:
                if (nextState.posX, nextState.posY, "s") in nextState.demolishedTiles:
                    tileDemolished = "S"
        else:
            if (nextState.posX, nextState.posY) in nextState.demolishedTiles:
                tileDemolished = "D"
            else:
                tileDemolished = "N"

        if nextState.isGoalState():
            #we have reached the goal. Return the relevant stats
            return (nextState.actionList, nextState.score, len(visited))

        elif (nextState.posX, nextState.posY, nextState.direction, tileDemolished) not in visited:
            visited.append((nextState.posX, nextState.posY, nextState.direction, tileDemolished))
            for successorState in nextState.getSuccessors():
                fringe.put((-(successorState.score - heuristic(successorState)), successorState))
Пример #22
0
class MinimumWeightMatchingWithEdges:
    """Find a minimum weight matching using a greedy method.
    
    Attributes
    ----------
    graph : input undirected graph
    mate : dict with nodes (values are edges or None)
    cardinality : number
    """
    # Bedzie potrzebne do problemu chinskiego listonosza.

    def __init__(self, graph):
        """The algorithm initialization."""
        if graph.is_directed():
            raise ValueError("the graph is directed")
        self.graph = graph
        self.mate = dict((node, None) for node in self.graph.iternodes())
        self.cardinality = 0
        self._pq = PriorityQueue()

    def run(self):
        """Executable pseudocode."""
        for edge in self.graph.iteredges():
            self._pq.put((edge.weight, edge))
        while not self._pq.empty():
            _, edge = self._pq.get()
            if (self.mate[edge.source] is None and 
                self.mate[edge.target] is None):
                    self.mate[edge.source] = edge
                    self.mate[edge.target] = ~edge
                    self.cardinality += 1
Пример #23
0
def find_path(startkey, goalkey, world):

    frontier = PriorityQueue()
    frontier.put({"key": startkey, "cost": 0}, 0)
    came_from = {startkey: None}
    cost_so_far = {startkey: 0}
    step = 0

    while not frontier.empty() and step < 100000:
        step += 1  # just safety
        current = frontier.get()
        if current["key"] == goalkey:
            break

        for neighbor in get_neighbors(current["key"], world):
            new_cost = cost_so_far[current["key"]] + neighbor["cost"]
            if new_cost < cost_so_far.get(neighbor["key"], 10000000):
                cost_so_far[neighbor["key"]] = new_cost
                neighbor["cost"] += heuristic(neighbor["key"], goalkey)
                frontier.put(neighbor)
                came_from[neighbor["key"]] = current["key"]

    if current["key"] != goalkey:
        return None

    key = goalkey
    path = []
    step = 0
    while key and step < 1000:
        key = came_from[key]
        path.insert(0, key)
    return path
Пример #24
0
def run(graph,start,goal):
    frontier = PriorityQueue()
    frontier.put((0,start))
    came_from = {}
    came_from[start] = None

    while not frontier.empty():
        current = frontier.get()[1]
        if current == goal:
            break
        for next in graph.neighbors(current):
            new_cost = graph.gcost(next,goal)
            if next not in came_from:
                frontier.put((new_cost,next))
                came_from[next] = current

    #for x in came_from:
    #    print x,came_from[x]
    print len(came_from)

    current = goal
    path = [current]
    while current != start:
        current = came_from[current]
        path.append(current)
    print path
Пример #25
0
class EventManager(object):
    """ Keeps track of and triggers events in our network simulation

    Instance Properties:
        Q - A priority queue of events ordered by time
    """

    def __init__(self):
        self._Q = PriorityQueue()
        self.t = 0

    def add_event(self, t, event, args):
        """ Add an event onto the event queue

        :param t: The time of the event
        :param event: The event to add
        :param args: A list of args for the event
        """
        self._Q.put((t, event, args))

    def pop_event(self):
        """ Getting the first event off of the event queue.
        
        :return: Returns a tuple consisting of the time, event, and the args
            for the event
        """
        return self._Q.get()

    def has_events(self):
        """ Whether or not the manager has any more events on its queue

        :return: True or False based on whether its empty
        """
        return not self._Q.empty()
Пример #26
0
 def greedy(self):
     # like DFS, but puts coords closest to goal up front
     pq = PriorityQueue(maxsize=0)
     pq.put_nowait((self.manhattan_distance(self.currPos, self.goalPos), (self.currPos, [])))
     visited = set()
     bestPath = None
     numNodes = 0
     while not pq.empty():
         priority, curr = pq.get_nowait()
         coord, path = curr
         visited.add(coord)
         if bestPath is not None and len(path) >= len(bestPath):
             pass
         elif self.getChar(coord) == '%': # wall
             pass
         else: # recursive case
             if self.getChar(coord) == '.': # goal
                 print "Num Nodes:", numNodes
                 print self.debug(path)
                 return path # return on first path found
             for adj, direction in self.adjacent(coord):
                 if adj not in visited and self.getChar(adj) != '%':
                     numNodes += 1
                     heur = self.manhattan_distance(adj, self.goalPos)
                     if bestPath is None: # preselect based on heuristic
                         pq.put_nowait((heur, (adj, path + direction)))
     return [] # impossible
Пример #27
0
 def travel(self):
     visitedNodes = 0
     optimalPath = []
     priorityQueue = PriorityQueue()
     optimalPathLen = -1
     priorityQueue.put(self.addNode(0, []))
     startTime = time.time()
     while not priorityQueue.empty():
         currentPath = priorityQueue.get()[1]
         if optimalPath:
             pathLen = self.graph.getPathLength(optimalPath)
             upperBound = self.graph.upperBound(self.graph.getPathLength(currentPath), currentPath)
             optimalPathLen = self.graph.getPathLength(optimalPath)
         # Jesli nie mamy sciezki lub jest ona gorsza od UB
         if not optimalPath or upperBound < pathLen:
             visitedNodes += 1
             # Jesli odwiedzono wszystkie miasta
             if len(currentPath) >= self.graph.size:
                 # Jesli mozna wrocic do miasta poczatkowego z ostatniego punktu sciezki
                 if self.graph.distance(currentPath[len(currentPath) - 1], 0) > 0:
                     currentPath = self.addNode(0, currentPath)[1]
                     # Jesli nie mamy sciezki lub zmodyfikowan jest lepsza niz dotychczasowe
                     if not optimalPath or optimalPathLen > self.graph.getPathLength(currentPath):
                         optimalPath = currentPath
             else:
                 for i in range(self.graph.size):
                     # Jesli rozwazane miasto nie bylo odwiedzone i istnieje prowadzaca do niego droga
                     if i not in currentPath and self.graph.distance(currentPath[len(currentPath) - 1], i) > 0:
                         newPath = copy.deepcopy(currentPath)
                         bound, newPath = self.addNode(i, newPath)
                         if not optimalPath or bound < optimalPathLen:
                             priorityQueue.put((bound, newPath))
     return [optimalPath, self.graph.getPathLength(optimalPath), visitedNodes, time.time() - startTime]
Пример #28
0
    def getMRV(self):
        
        q = PriorityQueue()
        for blank in self.blanks:
            possible = self.getPossibleValues(blank, True)
	    q.put((len(possible), blank))
        blanks = []
        blanks.append(q.get())
        minVal = blanks[0][0]

        while not q.empty(): #Get all equally-prioritized blanks
            next = q.get()
            if next[0] == minVal:
                blanks.append(next)
            else:
                break
            
        maxDeg = len(self.getNeighborBlanks(blanks[0][1]))
        maxDegBlank = blanks[0]

        for blank in blanks:
            degree = len(self.getNeighborBlanks(blank[1]))
            if degree > maxDeg:
                maxDegBlank = blank
                maxDeg = degree
        return maxDegBlank[1]
Пример #29
0
def main():
    seed = (0, str(467959))
    unique = set()
    unique.add(seed)
    nextOnes = PriorityQueue()
    nextOnes.put(seed)
    _prev = list(open('./visited.txt', 'r').read())

    for item in _prev:
        unique.add(item)

    global beforeNext

    while (not nextOnes.empty()):
        summID = nextOnes.get()
        summID = summID[1]
        url = makeURL(summID)
        json = performReq(url)
        matches = getMatches(json)
        matches.sort(reverse=True)
        if matches == list():
            nextOnes.put(summID)
            continue
        printMatches(matches)
        scrapeSummIDs = getSummonerIds(matches)

        for summId in scrapeSummIDs:
            if summId[1] not in unique:
                nextOnes.put(summId)
                unique.add(summId[1])
        beforeNext = 0
Пример #30
0
def IDAsearch(state, goalBoard, N):
	
	Q = PriorityQueue()
	initial_cost = Heuristic(state[1], N)
	Q.put((state, initial_cost), initial_cost)
	current_threshold = initial_cost
	next_threshold    = initial_cost
	visited = []
	while(Q.empty() != True):
	
		current_threshold = next_threshold
		next_threshold    = maxint
		visit = Q.get()
		print visit
		con = 0
		if(check(visit[0][1], goalBoard, N) == 0):
				#print "f**k yeah, found it"
				return visit[0][2]
		elif(visit[1] <= current_threshold):
			if visit[0][1] not in visited:
				con = 0
			else:
				con = 1	
		if(con == 0):				
			children = getNextState(visit[0], N)
			CQ = PriorityQueue()
			for child in children:
				b = Heuristic(child[1], N)
				h =  b + 1
				if( h < next_threshold):
					next_threshold = h	
				if child[1] not in visited:
					Q.put((child, h), h)
									
		visited.append(visit[0][1])
Пример #31
0
 def mergeKLists(self, lists):
     """
     :type lists: List[ListNode]
     :rtype: ListNode
     """
     if not lists:
         return None
     dummy = res = ListNode(0)
     tmp = PriorityQueue()
     for l in lists:
         if l:
             tmp.put((l.val,l))
     while not tmp.empty():
         val, node = tmp.get()
         res.next = ListNode(val)
         res = res.next
         node = node.next
         if node:
             tmp.put((node.val, node))
     return dummy.next
    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
Пример #33
0
 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()
Пример #34
0
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        head = current = ListNode(0)
        q = PriorityQueue()
        for l in lists:
            if l:
                q.put((l.val, l))

        while not q.empty():
            val, node = q.get()
            current.next = ListNode(val)
            current = current.next
            node = node.next
            if node:
                q.put((node.val, node))

        return head.next
Пример #35
0
 def mergeKLists(self, lists):
     """
     :type lists: List[ListNode]
     :rtype: ListNode
     """
     m_queue = PriorityQueue()
     for node in lists:
         if node:
             m_queue.put((node.val, node))
     tail = ListNode(0)
     head = tail
     while not m_queue.empty():
         now_val, now_node = m_queue.get()
         p = ListNode(now_val)
         tail.next = p
         tail = p
         now_node = now_node.next
         if (now_node):
             m_queue.put((now_node.val, now_node))
     return head.next
Пример #36
0
def aStar(state):
    frontier = PriorityQueue()
    for move in state.getTransitions():
        frontier.put((0, move))
    while not frontier.empty():
        dist, curr = tuple(frontier.get())
        position = curr[0]
        targets = list(curr[1])
        if len(targets) == 0:
            break
        state.move(position, targets)
        cost = len(state.currentPath)
        state.costs[position][tuple(sorted(targets))] = cost
        for neighbor, targets in state.getTransitions():
            if len(targets) == 0:
                return
            if state.costs[neighbor][tuple(sorted(targets))] > cost + 1:
                state.costs[neighbor][tuple(sorted(targets))] = cost + 1
                priority = cost + heuristic(position, targets)
                frontier.put((priority, (neighbor, targets)))
Пример #37
0
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        sentinel = current = ListNode(0)

        queue = PriorityQueue()
        for node in lists:
            if node:
                queue.put((node.val, node))

        while not queue.empty():
            _, node = queue.get()
            current.next = node
            current = node
            if node.next:
                queue.put((node.next.val, node.next))

        return sentinel.next
Пример #38
0
def branch_and_bound(graph, start, goal):
    if start == goal:
        return list(start)

    paths = PriorityQueue()
    for node in graph.get_connected_nodes(start):
        paths.put_nowait((path_length(graph, [start, node]), [start, node]))

    while not paths.empty():
        path = paths.get_nowait()
        if path[1][-1] == goal:
            return path[1]
        else:
            cnodes = graph.get_connected_nodes(path[1][-1])
            for node in cnodes:
                if path[1].count(node) == 0:
                    epath = list(path[1])
                    epath.append(node)
                    paths.put_nowait((path_length(graph, epath), epath))
    return []
Пример #39
0
    def mergeKLists(self, lists):
        """
        Two solutions provided, one runs in O(N log k) where N is the total number of nodes and k is the number of lists, the best runtime is 180ms, this should be the fastest way of solving this problem, however, my second solution, which is putting everything into a list and then sort it, then create a ListNode for each value, this one should runs in O(N logN) time, but when I tried on LeetCode, the best runtime is 84ms which is much faster than the first solution, I am guessing it because I used Python list.sort() method which is already optimized to run in shorter time whenever possible.
        """
        pqueue = PriorityQueue()
        for l in lists:
            if l:
                pqueue.put((l.val, l))

        head = ListNode(-1)
        cur_node = head
        while not pqueue.empty():
            val, node = pqueue.get()
            cur_node.next = node
            cur_node = node
            node = node.next
            if node:
                pqueue.put((node.val, node))
        return head.next
        """
def solve(initial_board):
    fringe = PriorityQueue()
    closed = {}
    priority_1 = calculate_heuristic_1(initial_board, 0)
    fringe.put((priority_1, (initial_board, "")))
    while not fringe.empty():
        (priority, (state, route_so_far)) = fringe.get()
        closed[tuple(state)] = priority
        #closed.append((priority,(state)))
        if is_goal(state):
            return (route_so_far)
        for (succ, move) in successors(state):
            route = str(route_so_far + " " + move)
            cost_so_far = len(route_so_far.split())
            priority_s = calculate_heuristic_1(succ, cost_so_far)
            if tuple(succ) not in closed:
                fringe.put((priority_s, (succ, route)))
            elif tuple(succ) in closed and closed[tuple(succ)] < closed[tuple(
                    state)]:
                fringe.put((priority_s, (succ, route)))
    def ans(self, matrix, k):
        if len(matrix) == 0 or len(matrix[0]) == 0 or k <= 0:
            return None

        from Queue import PriorityQueue

        pq = PriorityQueue()

        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                pq.put((matrix[i][j], matrix[i][j]))

        i = 0
        res = None
        while i < k:
            if not pq.empty():
                res = pq.get()[1]
            i += 1

        return res
Пример #42
0
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 get_inferred_norms(self, topNorms=1):
     call(["java", self.javaAppClass])
     pq = PriorityQueue()
     normProbabilities = {}
     with open(self.oniOutputFileName, 'r') as fOutOni:
         for line in fOutOni:
             parts = line.split(
             )  # norm as a string of action chars, and then probability
             if len(parts) > 0:
                 norm = ('eventually', parts[0][0]) if len(
                     parts[0]) == 1 else (parts[0][0], 'next', parts[0][1])
                 pq.put((float(parts[1]), norm))
                 normProbabilities[norm] = float(parts[1])
     with open(self.pniOutputFileName, 'r') as fOutPni:
         for line in fOutPni:
             parts = line.split(
             )  # norm as a string of action chars, and then probability
             if len(parts) > 0:
                 norm = ('never', parts[0][0]) if len(
                     parts[0]) == 1 else (parts[0][0], 'not next',
                                          parts[0][1])
                 pq.put((float(parts[1]), norm))
                 normProbabilities[norm] = float(parts[1])
     sorted_norms = []
     while not pq.empty():
         sorted_norms += [pq.get()[1]]
     norms = [x for x in reversed(sorted_norms)]
     # Check that we select either the topNorms, or the first ones with the same odds
     for (i, n) in enumerate(norms):
         if normProbabilities[n] == 0:
             topNorms = i
             break
         if (i + 1 == topNorms):
             tied = len(norms) > i + 1 and (
                 normProbabilities[n] == normProbabilities[norms[i + 1]])
             if (tied):
                 topNorms += 1
             else:
                 break
     #endfor
     return norms[0:topNorms]
Пример #44
0
def astar_multi(env,
                starts,
                goals,
                constraint_fn=lambda node, lastnode, t: True):
    starts = tuple(starts)
    goals = tuple(goals)
    pq = PriorityQueue()
    cost = 0.0
    t = 0.0
    heur = sum(
        [env.estimate(start, goal, t) for start, goal in zip(starts, goals)])
    costmap = {starts: cost}
    prevmap = {starts: None}
    pq.put((heur + cost, starts, t))
    while not pq.empty():
        totcost, curr, t = pq.get()
        at_goal = all([node == goal for node, goal in zip(curr, goals)])
        if at_goal:
            return construct_path_multi(prevmap, curr)

        transitions = [env.next(node, t) for node in curr]
        children = [[t[0] for t in node] for node in transitions]
        step_costs = [[t[1] for t in node] for node in transitions]
        children_combined = combine_actions(children)
        step_costs_combined = combine_actions(step_costs)
        for child, step_cost in zip(children_combined, step_costs_combined):
            if len(set(child)) < len(child):  # skip if there is a collision
                continue
            child_t = t + 1
            if not constraint_fn(child, curr, child_t):
                continue
            child_cost = costmap.get(curr, float('inf')) + sum(step_cost)
            if child_cost < costmap.get(child, float('inf')):
                prevmap[child] = curr
                costmap[child] = child_cost
                child_totcost = sum([
                    env.estimate(child_i, goal_i, child_t)
                    for child_i, goal_i in zip(child, goals)
                ]) + child_cost
                pq.put((child_totcost, child, child_t))
    return None
Пример #45
0
def find_path(start, goal):
    global xx
    im = Image.open("output.png")  #Can be many different formats.
    output = Image.new('RGBA', im.size)
    pix = im.load()
    dimensions = im.size  #Get the width and hight of the image for iterating over
    width = dimensions[0]
    height = dimensions[1]
    # initial parameters
    frontier = PriorityQueue()
    frontier.put(start, 0)
    closed_set = []
    costs_so_far = {}
    came_from = {}
    open_set = [start]
    costs_so_far[start] = 0
    came_from[start] = None
    max_y = height
    max_x = width
    while not frontier.empty():
        xx = xx + 1
        current = frontier.get()
        if current[0] == goal[0] and current[1] == goal[1]:
            break
        x = current[0]
        y = current[1]
        for i in range(-1, 2):
            for j in range(-1, 2):
                if x + i < max_x and y + j < max_y and x + i >= 0 and y + j >= 0 and x + i != x and y + j != y:
                    new_cost = costs_so_far[current] + pix[x + i, y + j][0]
                    if (x + i, y +
                            j) not in costs_so_far or new_cost < costs_so_far[
                                (x + i, y + j)]:
                        costs_so_far[(x + i, y + j)] = new_cost
                        priority = new_cost + heuristic(goal, (x + i, y + j))
                        frontier.put((x + i, y + j), priority)
                        came_from[(x + i, y + j)] = current
        if xx > 1000:
            break
            #print current
    return (came_from, costs_so_far)
class Dijkstra:
    def __init__(self, graph):
        self.graph = graph
        # Shortest path tree as a dictionary.
        self.parent = dict((node, None) for node in self.graph.iternodes())
        self.distance = dict(
            (node, float("inf")) for node in self.graph.iternodes())
        self.source = None
        self._in_queue = dict((node, True) for node in self.graph.iternodes())
        self._pq = PriorityQueue()

    def run(self, source):
        self.source = source
        self.distance[source] = 0
        for node in self.graph.iternodes():
            self._pq.put((self.distance[node], node))
        while not self._pq.empty():
            _, node = self._pq.get()
            if self._in_queue[node]:
                self._in_queue[node] = False
            else:
                continue
            for edge in self.graph.iteroutedges(node):
                if self._in_queue[edge.target] and self._relax(edge):
                    self._pq.put((self.distance[edge.target], edge.target))

    def _relax(self, edge):
        alt = self.distance[edge.source] + edge.cost
        if self.distance[edge.target] > alt:
            self.distance[edge.target] = alt
            self.parent[edge.target] = edge.source
            return True
        return False

    def path(self, target):
        if self.source == target:
            return [self.source]
        elif self.parent[target] is None:
            raise ValueError("no path to target")
        else:
            return self.path(self.parent[target]) + [target]
Пример #47
0
def search(targest_artist_profile, ogartist, connection):
    underrated = PriorityQueue()
    lokey = set()
    fringe = q.Queue()
    fringe.put(ogartist)
    getRelatedArtists_bfs(ogartist, lokey, {ogartist[1]}, fringe, [])

    quadrant_size = len(lokey) / 4
    lokey_list = list(lokey)
    processes = []
    qu = mp.Queue()
    for i in range(0, 4):
        process = Process(
            target=generateProfilePriority,
            args=(lokey_list[0 + (quadrant_size * i):(quadrant_size * i) +
                             quadrant_size], targest_artist_profile, qu))
        process.start()
        processes += [process]

    for process in processes:
        process.join()

    print '-------------results--------------'
    while not qu.empty():
        item = qu.get()
        print item
        underrated.put(item)

    results = []
    while not underrated.empty():
        item = underrated.get()
        results.append(item)

    a = (json.dumps({"a": results})).encode()
    json_file_size = str(len(a))

    print(json_file_size)
    connection.send(json_file_size)
    connection.send("\n")
    connection.send(a)
    print(a)
Пример #48
0
    def AStar(self, heuristic):
        startTime = time()
        expanded = 0
        PQueue = PriorityQueue()
        visited = set()
        queueGrids = set()  #Grids In Queue But Not Visited Yet
        PQueue.put((heuristic(self.initialState), self.initialState))

        while (not PQueue.empty()):
            front = (PQueue.get())[1]
            queueGrids.discard(front.grid)

            if front.grid in visited:  #Visited Before
                continue

            if front.grid in queueGrids:  #Found in Queue
                for node in PQueue.queue:
                    grid = node[1].grid

                    if grid == front.grid:
                        if node[0] > front.cost + heuristic(node[1]):
                            node[0] = front.cost + heuristic(node[1])

            #Processing
            if front.isGoal():
                path = front.backTrack()
                #self.drawGrids(path)
                self.processResult(path, front.cost, expanded,
                                   time() - startTime,
                                   "AStar-" + heuristic.__name__[:9])
                return path

            visited.add(front.grid)
            expanded += 1
            queueGrids.add(front.grid)

            children = front.generateChildren()  #Expanding
            for child in children:
                PQueue.put((heuristic(child) + child.cost, child))

        return False
Пример #49
0
    def a_star_tsp(self, num_cities, g, s_city_name):
        s_time = time.time()

        num_nodes = 0
    
        s = g[s_city_name]

        q = PriorityQueue()

        q.put((0, [[s_city_name], 0]))
        num_nodes += 1
    
        while not q.empty():
            temp  = q.get()[1]
            path = temp[0]
            prev_acc_cost = temp[1]
        
            if time.time() - s_time > 300:
                return path, prev_acc_cost, num_nodes, False

            # Travelled all cities and then back to start
            if len(path) == num_cities + 1:
                return path, prev_acc_cost, num_nodes, True

            # Travelled all cities 
            if len(path) == num_cities:
                heur, acc_cost = self.calc_heur(g, path, s_city_name, s, prev_acc_cost)
                new_path = path[:]
                new_path.append(s_city_name)
                q.put((heur, [new_path, acc_cost]))
                num_nodes += 1
            # Haven't travelled all cities
            else:
                not_visited = set(path).symmetric_difference(set(g.keys()))

                for city in not_visited:
                    heur, acc_cost = self.calc_heur(g, path, city, s, prev_acc_cost)
                    new_path = path[:]
                    new_path.append(city)
                    q.put((heur, [new_path, acc_cost]))
                    num_nodes += 1
Пример #50
0
def merge(lists):
    # error checking
    if not lists:
        return []
    lists = filter(lambda x: x != [], lists)

    # initialize priority queue
    pqueue = PriorityQueue()
    for lst in lists:
        if lst:
            pqueue.put((lst[0], lst[1:]))

    # merge the arrays
    result = []
    while not pqueue.empty():
        elt = pqueue.get()
        num, rest = elt[0], elt[1]
        result.append(num)
        if rest:
            pqueue.put((rest[0], rest[1:]))
    return result
Пример #51
0
def getP3(puzzle, pattern):
    output = ''
    tempMap = {}
    pq = PriorityQueue()
    for key in pattern:
        tempMap[key] = 0
        pq.put((key, key))
        #print 'keyA', key
    for i in range(len(puzzle)):
        for j in range(len(puzzle)):
            if puzzle[i][j] in pattern:
                temp = ''
                temp += str(i + 1)
                temp += str(j + 1)
                tempMap[puzzle[i][j]] = temp
                #print 'num',puzzle[i][j],i,j
    while not pq.empty():
        key = pq.get()[1]
        output += str(tempMap[key])
        #print 'keyB', key, 'value', tempMap[key]
    return output
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        head = point = ListNode(0)  # dummy node to point to new linked list
        q = PriorityQueue()

        # initial iteration through lists, if linked list not empty, put its head as a (value, node) pair in PQ
        for l in lists:
            if l: q.put((l.val, l))

        # get the (value, node) pair at the front of the PQ and add a new node with the value to the linked list
        # use node.next to get the next lowest element of the linked list to add to the PQ
        while not q.empty():
            val, node = q.get()
            point.next = ListNode(val)
            point = point.next
            node = node.next
            if node: q.put((node.val, node))
        return head.next
    def mergeKLists(self, lists):
        priorityQueue = PriorityQueue()

        for l in lists:
            if l:
                priorityQueue.put((l.val, l))

        head = ListNode(-1)
        pointer = head

        while not priorityQueue.empty():
            nodeVal, node = priorityQueue.get()
            pointer.next = ListNode(nodeVal)

            pointer = pointer.next
            node = node.next

            if node:
                priorityQueue.put((node.val, node))

        return head.next
Пример #54
0
def aStarSearch(graph, h, start, goal):
    frontier = PriorityQueue()
    frontier.put((0, start))

    cost = {}
    cost[start] = 0

    parents = {}
    while not frontier.empty():
        _, current = frontier.get()

        if current == goal:
            return backtrace(parents, start, goal)

        successors = graph[current]

        for successor in successors:
            cost[successor] = cost[current] + graph[current][successor]

            parents[successor] = current
            frontier.put((h[successor] + cost[successor], successor))
Пример #55
0
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        from Queue import PriorityQueue
        if not lists:
            return None
        pq = PriorityQueue()
        for lst in lists:
            if lst:
                pq.put((lst.val, lst))

        dummy = cur = ListNode(None)
        while not pq.empty():
            v, nd = pq.pop()
            cur.next = nd
            cur = cur.next
            if nd.next:
                pq.put((nd.next.val, nd.next))
        return dummy.next
Пример #56
0
def AStar():
    queue = PriorityQueue()
    cur_node = Node(0, 0)
    queue.put((get_FCost(cur_node), cur_node))
    visited = [get_index(cur_node)]
    path = [-1 for _ in xrange(width * height)]
    while not queue.empty():
        _, cur_node = queue.get()

        for node in find_next_nodes(cur_node):
            if get_index(node) in visited:
                continue

            path[get_index(node)] = get_index(cur_node)

            if is_target(node):
                print_path(path)
                return
            queue.put((get_FCost(node), node))
            visited.append(get_index(node))
    print 'not found'
Пример #57
0
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        from Queue import PriorityQueue  # in py3, use queue

        head = p = ListNode(0)
        q = PriorityQueue()
        for l in lists:
            if l:
                # in py3, 当第一个值一样的时候,比较第二个值,所以若第二值不支持比较,就会报错。
                q.put((l.val, l))
        while not q.empty():
            val, node = q.get()
            p.next = node
            p = p.next
            if node.next:
                q.put((node.next.val, node.next))

        return head.next
Пример #58
0
def a_star_search(graph, start, goal):
    frontier = PriorityQueue()
    frontier.put(start, 0)
    came_from = {start: None}
    cost_so_far = {start: 0}

    while not frontier.empty():
        current = frontier.get()

        if current == goal:
            break

        for next in graph.neighbors(current):
            new_cost = cost_so_far[current] + graph.cost(current, next)
            if next not in cost_so_far or new_cost < cost_so_far[next]:
                cost_so_far[next] = new_cost
                priority = new_cost + heuristic(goal, next)
                frontier.put(next, priority)
                came_from[next] = current

    return came_from, cost_so_far
Пример #59
0
    def lazy_prim_simplified(self):
        """
        wrap a method visit() to make it more compact
        :return:
        """
        processed = {}
        pq = PriorityQueue()
        # start from 0
        pq = self.visit(0, pq, processed)

        while not pq.empty():
            cur_node_w, cur_node_from, cur_node_to = pq.get()
            # if processed, do nothing
            if processed.get(cur_node_to) is True:
                continue
            # if not processed yet, it is one edge in MST
            self.mst.append((cur_node_from, cur_node_to, cur_node_w))
            # visit the other node in current minimum weight edge
            pq = self.visit(cur_node_to, pq, processed)

        self.mst_weight = self._calc_weight()
 def mergeKLists(self, lists):
     """
     :type lists: List[ListNode]
     :rtype: ListNode
     """
     dummy = cur = ListNode(0)
     queue = PriorityQueue()
     # O(k)
     for l in lists:
         if l:  # there may be empty linked list
             queue.put((l.val, l))
     # O(nlogk),因为一共有n个元素
     while not queue.empty():
         # O(logk)
         val, node = queue.get()
         cur.next = node
         cur = cur.next
         node = node.next
         if node:
             queue.put((node.val, node))
     return dummy.next