def construct_graph_from_json(my_graph, list):
neighbors = list['neighbors']
added_queue = set()
added_queue.add(list['id'])
queue = Queue(maxsize=0)
queue.put(list['neighbors'][0]['id'])
parent = list['id']
print("Constructing graph... ")
while queue.qsize() > 0:
for nnode in neighbors:
added_queue.add(nnode['id'])
weight = transition_state(parent, nnode['id'])
if (nnode['id'] != '7f3dc077574c013d98b2de8f735058b4'):
my_graph.add_edge(
g.Edge(g.Node(parent), g.Node(nnode['id']),
weight['event']['effect']))
if 'f1f131f647621a4be7c71292e79613f9' not in added_queue:
queue.put(nnode['id'])
print("Queue size is: " + str(queue.qsize()))
parent = queue.get()
room = get_state(parent)
neighbors.clear()
neighbors = room['neighbors']
print("Constructed Graph: " + str(my_graph))
return my_graph
def test_a_star_3(self):
start_time = time.time()
for g in self.graph_3s:
path = utils.convert_edge_to_grid_actions(
searches.a_star_search(g, graph.Node(utils.Tile(3, 0, "@1")),
graph.Node(utils.Tile(2, 7, "@2"))))
self.assertTrue(string_equal_without_order(path, "SSSSEESESSWWWW"))
print("A_star_3: %.6f seconds" % (time.time() - start_time))
def test_a_star_5(self):
start_time = time.time()
expected_path = "SSSSSSSSSSEESSEESESESSEESSEESESESESESSEESESESESESESSESEESESESSESEESSEESSEESESESESESSESEESSESESEESSESEESESSESEESESESESESSEESESESESESESESESESSEESESESESESESSEESSEESESSESEESSEESESSEESESESESESESSEESESESSEESESSESEESSEESESESESSEESSESEESESSESESESESEESSEESESESESESESESESESESESESESESESSEESESSEESSEESESESESSEESESESSEESESESSEESESESESESESESESESESESESESSESEESSEESESSEESESSEESSEESESSEESESESESESESESESESESSEESEEEESSSSSE"
path = utils.convert_edge_to_grid_actions(
searches.a_star_search(self.graph_5,
graph.Node(utils.Tile(4, 0, "@1")),
graph.Node(utils.Tile(201, 206, "@5"))))
print("A_star_5: %.6f seconds" % (time.time() - start_time))
self.assertTrue(string_equal_without_order(path, expected_path))
def test_a_star_1(self):
start_time = time.time()
for g in self.graph_1s:
self.assertEqual(
"SSSSE",
utils.convert_edge_to_grid_actions(
searches.a_star_search(g,
graph.Node(utils.Tile(3, 0, "@1")),
graph.Node(utils.Tile(4, 4,
"@6")))))
print("A_star_1: %.6f seconds" % (time.time() - start_time))
def test_dijkstra_5(self):
for g in self.graph_2s:
self.assertEqual([
graph.Edge(graph.Node(0), graph.Node(6), 3),
graph.Edge(graph.Node(6), graph.Node(4), 1),
graph.Edge(graph.Node(4), graph.Node(5), 5)
], searches.dijkstra_search(g, graph.Node(0), graph.Node(5)))
def test_dijkstra_3(self):
for g in self.graph_1s:
self.assertEqual([
graph.Edge(graph.Node(1), graph.Node(2), 1),
graph.Edge(graph.Node(2), graph.Node(4), 1),
graph.Edge(graph.Node(4), graph.Node(5), 1)
], searches.dijkstra_search(g, graph.Node(1), graph.Node(5)))
def test_dijkstra_1(self):
for g in self.graph_1s:
self.assertEqual([
graph.Edge(graph.Node(1), graph.Node(3), 1),
graph.Edge(graph.Node(3), graph.Node(10), 1),
graph.Edge(graph.Node(10), graph.Node(8), 1)
], searches.dijkstra_search(g, graph.Node(1), graph.Node(8)))
def test_dfs_4(self):
for g in self.graph_2s:
self.assertEqual([
graph.Edge(graph.Node(0), graph.Node(1), 4),
graph.Edge(graph.Node(1), graph.Node(2), 7),
graph.Edge(graph.Node(2), graph.Node(5), 2)
], searches.dfs(g, graph.Node(0), graph.Node(5)))
def test_bfs_3(self):
for g in self.graph_1s:
self.assertEqual([
graph.Edge(graph.Node(1), graph.Node(2), 1),
graph.Edge(graph.Node(2), graph.Node(4), 1),
graph.Edge(graph.Node(4), graph.Node(5), 1)
], searches.bfs(g, graph.Node(1), graph.Node(5)))
def test_bfs_1(self):
for g in self.graph_1s:
self.assertEqual([
graph.Edge(graph.Node(1), graph.Node(3), 1),
graph.Edge(graph.Node(3), graph.Node(10), 1),
graph.Edge(graph.Node(10), graph.Node(8), 1)
], searches.bfs(g, graph.Node(1), graph.Node(8)))
def bfs(initial_node, dest_node):
"""
Breadth First Search
uses graph to do search from the initial_node to dest_node
returns a list of actions going from the initial node to dest_node
"""
queue = []
actions = []
queue.append([initial_node])
while queue:
path = queue.pop(0)
# last node in path
node = path[-1]
if node == dest_node:
# convert nodes to edges
for i in range(len(path) - 1):
edge = g.Edge(path[i], path[i + 1], transition_state(path[i].data, path[i + 1].data)['event']['effect'])
actions.append(edge)
return actions
for neighbor_room in get_state(node.data)['neighbors']:
neighbor = g.Node(neighbor_room['id'])
new_path = list(path)
new_path.append(neighbor)
queue.append(new_path)
def queue_search(initial_node, dest_node, visit_queue, dijkstra=False):
distances = {}
distance_paths = {}
parents = {}
path = []
path_trace_tile = None
distances[initial_node] = 0
distance_paths[initial_node] = [initial_node]
visit_queue.put((0, initial_node))
while not visit_queue.empty():
entry = visit_queue.get()
current = entry[1]
if entry[0] != distances[current]:
continue
current_state = get_state(current)
for neighbor in current_state['neighbors']:
adjacent = neighbor['id']
possible_distance = distances[current] + (-1 * transition_state(
current, neighbor['id'])['event']['effect'])
possible_distance_path = distance_paths[current] + [adjacent]
if adjacent not in distances or (
dijkstra and possible_distance < distances[adjacent]
and len(possible_distance_path) == len(
set(possible_distance_path))):
distances[adjacent] = possible_distance
distance_paths[adjacent] = possible_distance_path
parents[adjacent] = current
if dest_node == adjacent:
path_trace_tile = adjacent
visit_queue.put((distances[adjacent], adjacent))
while path_trace_tile in parents:
distance = transition_state(parents[path_trace_tile],
path_trace_tile)['event']['effect']
path.append(
graph.Edge(graph.Node(parents[path_trace_tile]),
graph.Node(path_trace_tile), distance))
path_trace_tile = parents[path_trace_tile]
return list(reversed(path))
def test_bfs_4(self):
for g in self.graph_2s:
self.assertEqual(
[
graph.Edge(graph.Node(0), graph.Node(3), 1),
graph.Edge(graph.Node(3), graph.Node(5), 11)
],
searches.bfs(g, graph.Node(0), graph.Node(5))
)
def test_bfs_5(self):
for g in self.graph_2s:
self.assertEqual(
[
graph.Edge(graph.Node(0), graph.Node(1), 4),
graph.Edge(graph.Node(1), graph.Node(2), 7)
],
searches.bfs(g, graph.Node(0), graph.Node(2))
)
def test_remove_edge(self):
# removing edges that doesn't exist should return false
self.assertEqual(
False,
self.graph_1.remove_edge(
graph.Edge(graph.Node(1), graph.Node(6), 1)))
self.assertEqual(
True,
self.graph_1.remove_edge(
graph.Edge(graph.Node(6), graph.Node(5), 1)))
self.assertEqual(False,
self.graph_1.adjacent(graph.Node(6), graph.Node(5)))
def dijkstra_search(initial_node, dest_node):
"""
Dijkstra Search
uses graph to do search from the initial_node to dest_node
returns a list of actions going from the initial node to dest_node
"""
dist = {}
prev = {}
queue = []
actions = []
visited = []
dist[initial_node] = 0
queue.append((0, initial_node))
while queue:
node = queue.pop(0)[1]
visited.append(node)
current_room = get_state(node.data)
for neighbor_room in current_room['neighbors']:
neighbor = g.Node(neighbor_room['id'])
alt = dist[node] - transition_state(node.data, neighbor.data)['event']['effect']
if neighbor not in dist or (alt < dist[neighbor] and neighbor not in visited):
queue.append((alt, neighbor))
dist[neighbor] = alt
prev[neighbor] = node
# sort
queue = sorted(queue, key=lambda priority: priority[0])
current = dest_node
# convert nodes to edges
while current != initial_node:
parent = prev[current]
actions = [g.Edge(parent, current, transition_state(parent.data, current.data)['event']['effect'])] + actions
current = parent
return actions
def test_add_node(self):
self.assertEqual(False, self.graph_1.add_node(graph.Node(1)))
self.assertEqual(False, self.graph_1.add_node(graph.Node(6)))
self.assertEqual(True, self.graph_1.add_node(graph.Node(11)))
def test_remove_node(self):
self.assertEqual(True, self.graph_1.remove_node(graph.Node(6)))
# check if the node is removed and neighbors of 9 is also removed
self.assertEqual([], self.graph_1.neighbors(graph.Node(9)))
# Removing a node that doens't exist in the graph should return false as noop
self.assertEqual(False, self.graph_1.remove_node(graph.Node(1234)))
def test_add_edge(self):
self.assertEqual(False, self.graph_1.adjacent(graph.Node(1), graph.Node(4)))
self.assertEqual(True, self.graph_1.add_edge(graph.Edge(graph.Node(1), graph.Node(4), 1)))
self.assertEqual([graph.Node(2),graph.Node(3),graph.Node(4)], self.graph_1.neighbors(graph.Node(1)))
self.assertEqual(True, self.graph_1.adjacent(graph.Node(1), graph.Node(4)))
# When adding edge that already existed, should return false
self.assertEqual(False, self.graph_1.add_edge(graph.Edge(graph.Node(1), graph.Node(2), 1)))
def test_remove_edge(self):
# removing edges that doesn't exist should return false
self.assertEqual(False, self.graph_1.remove_edge(graph.Edge(graph.Node(1), graph.Node(6), 1)))
self.assertEqual(True, self.graph_1.remove_edge(graph.Edge(graph.Node(6), graph.Node(5), 1)))
self.assertEqual(False, self.graph_1.adjacent(graph.Node(6), graph.Node(5)))
def test_add_edge(self):
self.assertEqual(False,
self.graph_1.adjacent(graph.Node(1), graph.Node(4)))
self.assertEqual(
True,
self.graph_1.add_edge(graph.Edge(graph.Node(1), graph.Node(4), 1)))
self.assertEqual(
[graph.Node(2), graph.Node(3),
graph.Node(4)], self.graph_1.neighbors(graph.Node(1)))
self.assertEqual(True,
self.graph_1.adjacent(graph.Node(1), graph.Node(4)))
# When adding edge that already existed, should return false
self.assertEqual(
False,
self.graph_1.add_edge(graph.Edge(graph.Node(1), graph.Node(2), 1)))
def test_remove_node(self):
self.assertEqual(True, self.graph_1.remove_node(graph.Node(6)))
# check if the node is removed and neighbors of 9 is also removed
self.assertEqual([], self.graph_1.neighbors(graph.Node(9)))
# Removing a node that doens't exist in the graph should return false as noop
self.assertEqual(False, self.graph_1.remove_node(graph.Node(1234)))
def test_add_node(self):
self.assertEqual(False, self.graph_1.add_node(graph.Node(1)))
self.assertEqual(False, self.graph_1.add_node(graph.Node(6)))
self.assertEqual(True, self.graph_1.add_node(graph.Node(11)))
def test_neighbors(self):
self.assertEqual([graph.Node(2), graph.Node(3)],
self.graph_1.neighbors(graph.Node(1)))
self.assertEqual([graph.Node(5), graph.Node(7)],
self.graph_1.neighbors(graph.Node(4)))
self.assertEqual([graph.Node(0)],
self.graph_1.neighbors(graph.Node(5)))
self.assertEqual([], self.graph_1.neighbors(graph.Node(8)))
self.assertEqual(
[graph.Node(1), graph.Node(3),
graph.Node(6)], self.graph_2.neighbors(graph.Node(0)))
self.assertEqual([], self.graph_2.neighbors(graph.Node(5)))
def test_adjacent(self):
self.assertEqual(True,
self.graph_1.adjacent(graph.Node(1), graph.Node(2)))
self.assertEqual(True,
self.graph_1.adjacent(graph.Node(3), graph.Node(6)))
self.assertEqual(True,
self.graph_1.adjacent(graph.Node(3), graph.Node(10)))
self.assertEqual(False,
self.graph_1.adjacent(graph.Node(1), graph.Node(6)))
self.assertEqual(False,
self.graph_1.adjacent(graph.Node(4), graph.Node(9)))
self.assertEqual(True,
self.graph_2.adjacent(graph.Node(1), graph.Node(2)))
self.assertEqual(True,
self.graph_2.adjacent(graph.Node(4), graph.Node(5)))
self.assertEqual(False,
self.graph_2.adjacent(graph.Node(1), graph.Node(5)))
def test_edge_comparison(self):
"""Test edge comparison"""
self.assertEqual(graph.Edge(graph.Node(1), graph.Node(2), 1),
graph.Edge(graph.Node(1), graph.Node(2), 1))
def test_node_comparison(self):
"""Test node comparison"""
self.assertEqual(graph.Node(1), graph.Node(1))
def test_dfs_2(self):
for g in self.graph_1s:
self.assertEqual(
[
graph.Edge(graph.Node(1), graph.Node(2), 1),
graph.Edge(graph.Node(2), graph.Node(4), 1),
graph.Edge(graph.Node(4), graph.Node(5), 1),
graph.Edge(graph.Node(5), graph.Node(0), 1),
graph.Edge(graph.Node(0), graph.Node(7), 1),
graph.Edge(graph.Node(7), graph.Node(10), 1)
],
searches.dfs(g, graph.Node(1), graph.Node(10))
)
print("Queue size is: " + str(queue.qsize()))
parent = queue.get()
room = get_state(parent)
neighbors.clear()
neighbors = room['neighbors']
print("Constructed Graph: " + str(my_graph))
return my_graph
if __name__ == "__main__":
# Your code starts here
empty_room = get_state('7f3dc077574c013d98b2de8f735058b4')
print("Original JSON: " + str(empty_room))
graph = construct_graph_from_json(g.AdjacencyList(), empty_room)
#print(transition_state(empty_room['id'], empty_room['neighbors'][0]['id']))
bfs_path = s.bfs(graph, g.Node('7f3dc077574c013d98b2de8f735058b4'),
g.Node('f1f131f647621a4be7c71292e79613f9'))
if bfs_path:
print("Bfs_path: " + str(bfs_path))
else:
print("Bfs_path: No Path Found")
dijkstra_path = dijkstra_search(graph,
g.Node('7f3dc077574c013d98b2de8f735058b4'),
g.Node('f1f131f647621a4be7c71292e79613f9'))
if dijkstra_path:
print("Dijkstra_path: " + str(dijkstra_path))
else:
print("Dijkstra_path: No Path Found")
# sort
queue = sorted(queue, key=lambda priority: priority[0])
current = dest_node
# convert nodes to edges
while current != initial_node:
parent = prev[current]
actions = [g.Edge(parent, current, transition_state(parent.data, current.data)['event']['effect'])] + actions
current = parent
return actions
if __name__ == "__main__":
# Your code starts here
empty_room_node = g.Node(get_state('7f3dc077574c013d98b2de8f735058b4')['id'])
dark_room_node = g.Node(get_state('f1f131f647621a4be7c71292e79613f9')['id'])
strings = bfs_path(empty_room_node, dark_room_node)
print("BFS path:")
for actions in strings[0]:
print(actions)
print("Total hp: " + strings[1])
strings = dijkstra_path(empty_room_node, dark_room_node)
print("\nDijkstra path:")
for actions in strings[0]:
print(actions)
print("Total hp: " + strings[1])
