def _compute_path(self, source, goal):
"""
Calculates the path connecting two given nodes with the least
possible weight using the A*-algorithm.
:param source:
The node the path is supposed to start on.
:param goal:
The node where the path is supposed to end on.
:return:
Dictionary with parent for each node where the parent is the node
which provides the shortest path to a given node.
"""
parent = {source: None}
shortest = defaultdict(lambda: float('inf'))
shortest[source] = 0
node_pq = pq.PriorityQueue((source, 0))
while node_pq:
node = node_pq.pop_task()
if node == goal:
return self._restore_path(parent, source, goal)
for adj_node in self.adj(node):
cost = shortest[node] + self.weight(node, adj_node)
if shortest[adj_node] > cost:
shortest[adj_node] = cost
parent[adj_node] = node
node_pq.add_task(adj_node,
cost + self.heuristic(adj_node, goal))
return []
def computeMST(G):
#New Graph
MST = {}
pq = priorityqueue.PriorityQueue('min')
#Create Edge List From Graph
for g in G:
for v in G[g]:
mytuple = G[g][v], (g, v)
pq.push(mytuple)
while (not pq.isempty()):
d, edge = pq.pop()
v, w = edge
marked[:] = []
DFS(MST, v)
if w not in marked:
edge1 = {w: d}
edge2 = {v: d}
if (MST.has_key(v)):
MST[v].update(edge1)
else:
MST[v] = edge1
if (MST.has_key(w)):
MST[w].update(edge2)
else:
MST[w] = edge2
#Return
return MST
def __init__(self, env, robot, connected=8, heuristic="eucledian"):
# Set the variables
self._env = env
self._robot = robot
# which cells to check
if not (connected == 8 or connected == 4):
self._connected = 8
else:
self._connected = connected
# how to calculate heuristics
if not (heuristic is "eucledian" or heuristic is "manhattan"):
self._heuristic = "eucledian"
else:
self._heuristic = heuristic
# steps for pose
self._step = 0.1
self._angle_step = 0.25 * math.pi
# set up the Queue
self._fringe = priorityqueue.PriorityQueue()
self._close_set = []
def find_shortest_paths(start_node, nodes, edges):
'''
Takes in a graph and starting node and returns a dictionary that can be used to
construct the shortest path to each other node.
'''
shortest_distances = dict()
unvisited = priorityqueue.PriorityQueue()
shortest_distances[start_node] = NodeInfo(0, None)
for node in (nodes - {start_node}):
shortest_distances[node] = NodeInfo(numpy.inf, None)
for node in nodes:
# print(type(shortest_distances[node].previous_weight))
# print(shortest_distances[node].previous_weight)
#
unvisited.add(node, shortest_distances[node].previous_weight)
while not unvisited.is_empty():
current_node = unvisited.pop()
for unvisited_node in (unvisited.keys()
& adjacent(current_node, edges)):
new_distance = shortest_distances[
current_node].previous_weight + get_weight(
current_node, unvisited_node, edges)
if new_distance < shortest_distances[
unvisited_node].previous_weight:
shortest_distances[
unvisited_node].previous_weight = new_distance
shortest_distances[unvisited_node].previous_node = current_node
unvisited.add(
unvisited_node,
shortest_distances[unvisited_node].previous_weight)
return shortest_distances
def weightedsetcover(S, w):
'''Weighted set cover greedy algorithm:
pick the set which is the most cost-effective: min(w[s]/|s-C|),
where C is the current covered elements set.
The complexity of the algorithm: O(|U| * log|S|) .
Finding the most cost-effective set is done by a priority queue.
The operation has time complexity of O(log|S|).
Input:
udict - universe U, which contains the <elem, setlist>. (dict)
S - a collection of sets. (list)
w - corresponding weight to each set in S. (list)
Output:
selected: the selected set ids in order. (list)
cost: the total cost of the selected sets.
'''
udict = {}
selected = list()
scopy = [] # During the process, S will be modified. Make a copy for S.
for index, item in enumerate(S):
scopy.append(set(item))
for j in item:
if j not in udict:
udict[j] = set()
udict[j].add(index)
pq = priorityqueue.PriorityQueue()
cost = 0
coverednum = 0
for index, item in enumerate(scopy): # add all sets to the priorityqueue
if len(item) == 0:
pq.addtask(index, MAXPRIORITY)
else:
pq.addtask(index, float(w[index]) / len(item))
print(len(udict))
while coverednum < len(udict):
a = pq.poptask() # get the most cost-effective set
#print("a ", a)
selected.append(a) # a: set id
cost += w[a]
#print("scopy[a] = ", len(scopy[a]))
coverednum += len(scopy[a])
# Update the sets that contains the new covered elements
for m in scopy[a]: # m: element
for n in udict[m]: # n: set id
if n != a:
scopy[n].discard(m)
if len(scopy[n]) == 0:
pq.addtask(n, MAXPRIORITY)
else:
pq.addtask(n, float(w[n]) / len(scopy[n]))
#print("here set cover, length = ", coverednum)
scopy[a].clear()
pq.addtask(a, MAXPRIORITY)
return selected, cost
def project_end_state(game):
order = pq.PriorityQueue()
for hero in game.heroes:
riches = project_end_gold(hero, game)
order.insert(hero.id, -riches)
final = []
while not order.is_empty():
final.append(order.remove())
return final
def sort_by_highest_value(locs, game):
q = pq.PriorityQueue()
for loc in locs:
q.insert(loc, -gold_value(loc, game))
locs = []
while not q.is_empty():
locs.append(q.remove())
return locs
def submodularsetcover(Q, w, T):
if len(Q) == 0 or len(T) == 0:
return [], 0
C = set() #elements of T covered so far
A = list() #sets added to solution
A_id = set() #set ids added to solution
Q1 = [] #a copy of Q
for index, item in enumerate(Q):
Q1.append(set(item))
alpha = priorityqueue.PriorityQueue()
for i in range(len(Q)):
a = w[i]
b = len(T.intersection(Q[i]))
if b == 0:
alpha.addtask(i, MAXPRIORITY)
else:
val = a / float(b)
alpha.addtask(i, val)
cost = 0
#print(T)
while (len(T) > 0):
#print(len(T))
#print("stuck up here in submodular")
choice = alpha.poptask()
A.append(Q[choice])
A_id.add(choice)
cost = cost + w[choice]
C = C.union(Q[choice])
T = T - C
for i in range(0, len(Q)):
a = w[i]
Q1[i] = Q1[i] - C
b = len(T.intersection(Q1[i]))
if b == 0:
alpha.addtask(i, MAXPRIORITY)
else:
val = a / float(b)
alpha.addtask(i, val)
#print("target "+str(T))
#print("Q1 "+str(Q1))
#print("I'm here")
return A, A_id
#priorityqueue test
import priorityqueue
# test basic pop function
a = priorityqueue.PriorityQueue()
a.add('alpha', 1)
a.add('charlie', 3)
a.add('delta', 4)
assert a.pop() == 'alpha'
assert a.pop() == 'charlie'
assert a.pop() == 'delta'
# test basic update function
a.add('alpha', 1)
a.add('charlie', 3)
a.add('delta', 4)
a.add('alpha', 5)
assert a.pop() == 'charlie'
assert a.pop() == 'delta'
assert a.pop() == 'alpha'
# test for stable pop
a.add('alpha', 1)
a.add('charlie', 3)
a.add('delta', 4)
a.add('alpha2', 1)
assert a.pop() == 'alpha'
assert a.pop() == 'alpha2'
assert a.pop() == 'charlie'
assert a.pop() == 'delta'
def weightedsetcover(G, S, costs, start_node, shortest_paths, pred, weight, heuristic_value, randomness):
'''Weighted set cover greedy algorithm:
pick the set which is the most cost-effective: min(w[s]/|s-C|),
where C is the current covered elements set.
The complexity of the algorithm: O(|U| * log|S|) .
Finding the most cost-effective set is done by a priority queue.
The operation has time complexity of O(log|S|).
Input:
udict - universe U, which contains the <elem, setlist>. (dict)
S - a collection of sets. (list)
w - corresponding weight to each set in S. (list)
Output:
selected: the selected set ids in order. (list)
cost: the total cost of the selected sets.
'''
w = weight
K = len(S)
udict = {}
selected = list()
adj = [] # During the process, S will be modified. Make a copy for S.
conquer_path = [start_node]
for index, item in enumerate(S):
adj.append(set(item))
for j in item:
if j not in udict:
udict[j] = set()
udict[j].add(index)
conquered_kingdoms = set()
unconquered_kingdoms = set([i for i in range(K)])
current_node = start_node
# print("PQ INITIALIZATION")
# print("-----------------")
pq = priorityqueue.PriorityQueue()
cost = 0
coverednum = 0
for index, node in enumerate(adj): # add all sets to the priorityqueue
if len(node) == 0:
pq.addtask(index, MAXPRIORITY)
# print("Added node", index, "with priority", MAXPRIORITY)
else:
priority = float(costs[index]) / value(G, start_node, index, unconquered_kingdoms, conquered_kingdoms, start_node, w, heuristic_value, randomness)
pq.addtask(index, priority)
# print("Added node", index, "with priority", priority, "(cost:", float(costs[index]), ", value:", value(G, start_node, index, unconquered_kingdoms, conquered_kingdoms, start_node), ")")
# print(adj)
while len(conquered_kingdoms) < K:
target_node = pq.poptask() # get the most cost-effective set
# print("Conquering node: ", target_node)
path_to_add = path(current_node, target_node, pred)[1:]
conquer_path.extend(path_to_add)
current_node = target_node
selected.append(target_node) # a: set id
cost += costs[target_node]
coverednum += len(adj[target_node])
conquered_kingdoms.add(target_node)
if target_node in unconquered_kingdoms:
unconquered_kingdoms.remove(target_node)
# pdb.set_trace()
for adjacent_vertex in [node for node in adj[target_node] if node != target_node]:
conquered_kingdoms.add(adjacent_vertex)
if adjacent_vertex in unconquered_kingdoms:
unconquered_kingdoms.remove(adjacent_vertex)
pq.addtask(adjacent_vertex, MAXPRIORITY)
#print("Adding task", adjacent_vertex, "with priority", MAXPRIORITY)
for n in udict[adjacent_vertex]:
if n != target_node:
adj[n].discard(adjacent_vertex)
# if len(adj[n]) == 0:
# pq.addtask(n, MAXPRIORITY)
# else:
# costs[n] = acquire_cost(G, target_node, n, shortest_paths)
# #pdb.set_trace()
# pq.addtask(n, costs[n] / value(G, target_node, n, unconquered_kingdoms, conquered_kingdoms))
# Update the sets that contains the new covered elements
# Commented out: only updates nodes that touched adjacent nodes that were removed
# for m in adj[target_node]: # m: element
# for n in udict[m]: # n: set id
# if n != target_node:
# adj[n].discard(m)
# if len(adj[n]) == 0:
# pq.addtask(n, MAXPRIORITY)
# else:
# pq.addtask(n, float(costs[n]) / len(adj[n]))
# Update the acquire cost of each unacquired vertex
for vertex in unconquered_kingdoms:
cost = acquire_cost(G, target_node, vertex, shortest_paths)
pq.addtask(vertex, cost / value(G, target_node, vertex, unconquered_kingdoms, conquered_kingdoms, start_node, w, heuristic_value, randomness))
adj[target_node].clear()
pq.addtask(target_node, MAXPRIORITY)
path_to_add = path(current_node, start_node, pred)[1:]
conquer_path.extend(path_to_add)
return selected, cost, conquer_path
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 6 18:05:18 2016
Test the priority queue
@author: dflemin3
"""
from __future__ import print_function
import numpy as np
import priorityqueue as priq
pq = priq.PriorityQueue()
print("Add 20 random ints to the priority queue.\n")
rand_ints = np.random.randint(0, 100, size=20)
for i in range(0, len(rand_ints)):
print("Inserting into pq:", rand_ints[i])
pq.insert(rand_ints[i])
print("\nCall delMin() 20 times.\n")
for i in range(0, len(rand_ints)):
print("delMin():", pq.delMin())