def shortest_path(self, v_start, v_end): # item structure: {'w': 11, 'path': ['va', 'vb', ...]} priority_queue = MinHeap(criterion='w') # structure: {..., 'v_name': {'w': 11, 'path': ['va', 'vb',...] }} best_tracks = {} curr_track = {'path': [v_start], 'w': 0, 'v': v_start} while True: for edge in self.vertex_edges[curr_track['v']]: new_track = { 'w': curr_track['w'] + edge['w'], 'path': curr_track['path'] + [edge['v2']] } priority_queue.insert(new_track) assert priority_queue.is_empty() == False min_track = priority_queue.getMin() while better_track_exists(min_track, best_tracks): min_track = priority_queue.getMin() if at_destination(min_track, v_end): return min_track best_tracks[min_track['path'][-1]] = min_track curr_track = min_track.copy() curr_track['v'] = min_track['path'][-1]
def shortest_path(self, start: Vertice, destination: Vertice, time: float) -> tuple: for v in self.__v.values(): v.set_distance(-1) v.set_parrent(None) unexplored = MinHeap(len(self.__v)) for v in self.__v.values(): unexplored.insert(v) unexplored.update(start.v_id(), 0) self.__v[start.v_id()].set_distance(0) traffic = 0 for edge in self.__traffic.keys(): for t in self.__traffic[edge]: if time <= t: traffic += 1 v = self.__v[edge[0]] u = self.__v[edge[1]] self.set_e_weight(v, u, self.__weight(v, u, traffic)) traffic = 0 explored = [] while not destination.v_id() in explored: v = unexplored.pop_min() explored.append(v.v_id()) for edge in self.__adj[v.v_id()]: if v.distance() + edge[1] < self.__v[edge[0]].distance(): unexplored.update(edge[0], v.distance() + edge[1]) self.__v[edge[0]].set_distance(v.distance() + edge[1]) self.__v[edge[0]].set_parrent(v) finded_path = [] curr = destination travel_time = 0 while curr is not start: finded_path.append(curr.v_id()) travel_time += self.e_weight(curr, curr.parrent()) curr = curr.parrent() travel_time *= 120 finded_path.append(curr.v_id()) for i in range(len(finded_path) - 1): self.__traffic[(finded_path[i], finded_path[i + 1])].append(time + travel_time) self.__traffic[(finded_path[i + 1], finded_path[i])].append(time + travel_time) finded_path.append(travel_time) return tuple(reversed(finded_path))
def solve_with_a_star(self): path = [] openList = MinHeap([]) entryFinder = {} initial_cost = self.heuristic[self.startingNode] openList.insert(initial_cost, [self.startingNode, []]) entryFinder[self.startingNode] = 0 closedList = [] memory_spend = 0 for i in range(1, MAX_ATTEMPTS): if openList.heap_size is 0: raise Exception("Not found a solution") else: if openList.heap_size > memory_spend: memory_spend = openList.heap_size p = openList.extract_min() cost_until_now = p[0] actual_city = p[1][0] if actual_city in entryFinder: entryFinder.pop(actual_city) if actual_city in self.objectives: finalPath = p[1][1] finalPath.append(actual_city) print(memory_spend) print(finalPath) print(cost_until_now) return adj_cities = self.graph[actual_city] closedList.append(actual_city) for adj_city in adj_cities: if adj_city not in closedList: gx = (cost_until_now - self.heuristic[actual_city] ) + adj_cities[adj_city]['distance'] cost = gx + self.heuristic[adj_city] if adj_city not in entryFinder: path = p[1][1] newPath = list(path) newPath.append(actual_city) openList.insert(cost, [adj_city, newPath]) entryFinder[adj_city] = cost else: if cost < entryFinder[adj_city]: path = p[1][1] newPath = list(path) newPath.append(actual_city) for i in range(1, openList.heap_size): if openList.heap[i][1][0] == adj_city: openList.heap[i][1][1] = newPath openList.decrease_priority(i, cost) entryFinder[adj_city] = cost break raise Exception("Max attempts reached")
def dijkstra(source, graph): cnt = 1 distance = {} heap = MinHeap(len(graph.nodes)) for i in graph.nodes: distance[i] = float('inf') distance[source] = 0 heap.insert((0, source)) while cnt != 0: dist, node = heap.removeMin() cnt -= 1 for i in graph.adjList[node]: if distance[i[0]] > dist + i[1]: distance[i[0]] = dist + i[1] heap.insert((distance[i[0]], i[0])) cnt += 1 return distance
if __name__ == '__main__': sup = MaxHeap([]) # MAX_HEAP inf = MinHeap([]) # MIN_HEAP n = 0 while True: # citesc numarul pe care vreau sa il inserez x = input("Numar: ") x = int(x) sup.insert(x) # inseram in max-heap if n % 2 == 0: if inf.heap_size > 0: # daca am elemente in minheap if sup.max() > inf.min( ): # daca radacina maxHeap-ului > radacina minHeapului # extrag radacinile si le inserez in cruce toMin = sup.pop_max() toMax = inf.pop_min() sup.insert(toMax) inf.insert(toMin) else: # daca numarul de numere e impar toMin = sup.pop_max() inf.insert(toMin) # extrag radacina maxHeap-ului si o inserez in minHeap n += 1 # crestem numarul de elemente procesate # getting the median if n % 2 == 0: print(sup.max() + inf.min()) / 2.0 else: print sup.max()
def a_star(start_state, heuristic_func, successors_gen, goal_predicate, cost_func=lambda *_: 1): """ Generalized implementation of A* search. Input: start_state: Initial state heuristic_func: Function of the form (state) -> heuristic value successors_gen: Generator which yields all successors for a given state: state -> yield successor state goal_predicate: Predicate to test whether the given state is a goal state: state -> True or False (Optional) cost_func: Function which returns the cost of a state transition: from_state, to_state -> cost Defaults to a cost of one. Returns: A list of the form [(x0, y0), (x1, y1), ..., (xn, yn)] representing a path from start to end node. """ # Memoization table, maps from state to corresponding node memo = {} # Initialize containers closed = set() open_ = MinHeap(key_attr='f') # Initialize starting node start = initialize_start_node(start_state, heuristic_func) open_.insert(start) memo[start_state] = start # Loop as long as there are nodes to process while open_: u = open_.extract_min() closed.add(u) # Test to see if goal state is reached if goal_predicate(u.state): print("Goal found!") return [node.state[1:] for node in create_path_to(u)] # Process successor states of current node for v_state in successors_gen(u.state): # Check if state has been previously encountered, create new by default if v_state in memo: v = memo[v_state] else: v = initialize_successor_node(u, v_state, heuristic_func, cost_func) memo[v_state] = v # Add to parents' list of successors u.successors.append(v) # In case of encountering a new node (not opened or closed) if v not in open_ and v not in closed: attach_and_eval(v, u, heuristic_func, cost_func) open_.insert(v) # If path is an improvement to previously discovered node elif u.g + cost_func(u.state, v.state) < v.g: attach_and_eval(v, u, heuristic_func, cost_func) # If successor is an internal node if v in closed: propagate_path_improvements(v, heuristic_func, cost_func)
from min_heap import MinHeap heap = MinHeap() heap.insert(5) heap.insert(10) heap.insert(1) heap.insert(4) heap.insert(7) heap.insert(2) print(heap) print(heap.min()) print(heap.remove()) print(heap) print(heap.remove()) print(heap)