def graph():
letters = Graph()
a = letters.add_node("a")
b = letters.add_node("b")
c = letters.add_node("c")
d = letters.add_node("d")
e = letters.add_node("e")
f = letters.add_node("f")
g = letters.add_node("g")
h = letters.add_node("h")
letters.add_edge(a, b)
letters.add_edge(b, c)
letters.add_edge(c, g)
letters.add_edge(a, d)
letters.add_edge(d, e)
letters.add_edge(d, h)
letters.add_edge(d, f)
letters.add_edge(h, f)
return letters
def test_bouquet():
g = Graph()
apple = g.add_node("apple")
g.add_edge(apple, apple, 10)
neighbors = g.get_neighbors(apple)
assert len(neighbors) == 1
assert neighbors[0].vertex.value == "apple"
assert neighbors[0].weight == 10
def test_add_edge():
g = Graph()
apple = g.add_node("apple")
banana = g.add_node("banana")
g.add_edge(apple, banana, 5)
neighbors = g.get_neighbors(apple)
assert len(neighbors) == 1
assert neighbors[0].vertex.value == "banana"
assert neighbors[0].weight == 5
def test_add_edge_interloper_end():
graph = Graph()
end = Vertex("end")
start = graph.add_node("start")
with pytest.raises(KeyError):
graph.add_edge(start, end)
def knight_graph(board_size):
kt_graph = Graph()
for row in range(board_size):
for col in range(board_size):
node_id = pos_to_node_id(row, col, board_size)
new_positions = gen_legal_moves(row, col, board_size)
for e in new_positions:
n_id = pos_to_node_id(e[0], e[1], board_size)
kt_graph.add_edge(node_id, n_id)
return kt_graph
def generate_sample_friend_network():
graph = Graph()
graph.add_edge('Alex', 'Bob')
graph.add_edge('Bob', 'Dan')
graph.add_edge('Bob', 'Charlie')
graph.add_edge('Charlie', 'Elsa')
graph.add_edge('Elsa', 'Genna')
return graph
def shortest_reach(n, edges, s):
graph = Graph(False)
for vertex in range(1, n + 1):
graph.add_vertex(vertex)
for begin, end, weight in edges:
graph.add_edge(begin, end, weight)
shortest_paths = graph.dijkstra_shortest_path(s)
return [
value.distance if value.distance != inf else -1
for key, value in sorted(shortest_paths.items()) if key != s
]
def create_graph3():
graph = Graph()
nodes = [1, 2, 3, 4, 5]
edges = [
(1, 3, 1), (1, 2, 2), (3, 6, 3),
(2, 4, 2), (4, 5, 1)
]
for n in nodes:
graph.add_node(n)
for e in edges:
graph.add_edge(e[0], e[1], e[2])
return graph
def create_graph():
graph = Graph()
nodes = [1, 2, 3, 4, 5]
edges = [
(1, 2, 1), (2, 3, 2),
(3, 4, 3), (4, 5, 6)
]
for n in nodes:
graph.add_node(n)
for e in edges:
# node1, node2, weight
graph.add_edge(e[0], e[1], e[2])
return graph
def cyclical_graph():
graph = Graph()
nodes = [1, 2, 3, 4, 5, 6, 7]
edges = [
(1, 2, 3), (2, 3, 3), (3, 5, 2),
(5, 4, 2), (5, 6, 1), (4, 2, 1),
(4, 7, 1)
]
for n in nodes:
graph.add_node(n)
for e in edges:
graph.add_edge(e[0], e[1], e[2])
return graph
def create_spaghetti():
graph = Graph()
nodes = [1, 2, 3, 4, 5, 6, 7, 8, 9]
edges = [
(1, 2, 3), (1, 3, 2), (1, 4, 5),
(2, 9, 5), (2, 5, 3), (2, 6, 6),
(3, 5, 5), (3, 7, 2), (4, 6, 6),
(4, 8, 2), (9, 5, 4), (6, 9, 4),
(7, 8, 5)
]
for n in nodes:
graph.add_node(n)
for e in edges:
graph.add_edge(e[0], e[1], e[2])
return graph
def test_add_edge(self):
print('Test: test_add_edge')
g = Graph()
print('Test: Invalid input')
self.assertRaises(ValueError, g.add_edge, None, None)
print('Test: general case')
n, n1 = g.add_node(), g.add_node()
g.add_edge(n, n1)
self.assertIn([n1, 0], n.neighbors)
n2 = g.add_node()
g.add_edge(n1, n2, 5)
self.assertIn([n2, 5], n1.neighbors)
print('Success: test_add_edge')
def build_graph(w_list):
d = {}
g = Graph()
for word in w_list:
for i in range(len(word)):
bucket = word[:i] + '_' + word[i + 1:]
if bucket in d:
d[bucket].append(word)
else:
d[bucket] = [word]
for bucket in d.keys():
for word1 in d[bucket]:
for word2 in d[bucket]:
if word1 != word2:
g.add_edge(word1, word2)
return g
def test_get_neighbors():
graph = Graph()
banana = graph.add_node("banana")
apple = graph.add_node("apple")
graph.add_edge(apple, banana, 44)
neighbors = graph.get_neighbors(apple)
assert len(neighbors) == 1
neighbor_edge = neighbors[0]
assert neighbor_edge.vertex.value == "banana"
assert neighbor_edge.weight == 44
def generate_sample_graph(is_directed=False):
'''
Will return a graph obj as such, either undirected or directed based on the optional arg:
undirected
[A] -> {'B', 'C'}
[B] -> {'A', 'D', 'E'}
[C] -> {'A', 'F'}
[D] -> {'B'}
[E] -> {'B', 'F'}
[F] -> {'E', 'C'}
directed
[A] -> {'C', 'B'}
[B] -> {'E', 'D'}
[C] -> {'F'}
[E] -> {'F'}
'''
graph = Graph(is_directed)
graph.add_edge('A', 'B')
graph.add_edge('A', 'C')
graph.add_edge('B', 'D')
graph.add_edge('B', 'E')
graph.add_edge('C', 'F')
graph.add_edge('E', 'F')
return graph
def graph():
realms = Graph()
pandora = realms.add_node("Pandora")
arendelle = realms.add_node("Arendelle")
metroville = realms.add_node("Metroville")
monstropolis = realms.add_node("Monstropolis")
narnia = realms.add_node("Narnia")
naboo = realms.add_node("Naboo")
realms.add_edge(pandora, arendelle)
realms.add_edge(arendelle, pandora)
realms.add_edge(arendelle, metroville)
realms.add_edge(arendelle, monstropolis)
realms.add_edge(metroville, arendelle)
realms.add_edge(metroville, monstropolis)
realms.add_edge(metroville, narnia)
realms.add_edge(monstropolis, arendelle)
realms.add_edge(monstropolis, metroville)
realms.add_edge(monstropolis, naboo)
realms.add_edge(narnia, metroville)
realms.add_edge(narnia, naboo)
realms.add_edge(naboo, metroville)
realms.add_edge(naboo, monstropolis)
realms.add_edge(naboo, narnia)
return realms
def dijkstra(aGraph, start):
pq = PriorityQueue()
start.set_distance(0)
pq.build_heap([(v, v.get_distance()) for v in aGraph])
while not pq.is_empty():
current_vert = pq.dequeue()[0]
for next_vert in current_vert.get_connections():
new_dist = current_vert.get_distance() + current_vert.get_weight(
next_vert)
if new_dist < next_vert.get_distance():
next_vert.set_distance(new_dist)
next_vert.set_pred(current_vert)
pq.decrease_priority(next_vert, new_dist)
if __name__ == '__main__':
g = Graph()
g.add_edge('u', 'v', 2)
g.add_edge('u', 'x', 1)
g.add_edge('u', 'w', 5)
g.add_edge('v', 'w', 3)
g.add_edge('v', 'x', 2)
g.add_edge('x', 'w', 3)
g.add_edge('x', 'y', 1)
g.add_edge('y', 'w', 1)
g.add_edge('w', 'z', 5)
g.add_edge('y', 'z', 1)
dijkstra(g, g.get_vertex('u'))
print(g.get_path('w'))
def planets():
graph = Graph()
metroville = graph.add_node("Metroville")
pandora = graph.add_node("Pandora")
arendelle = graph.add_node("Arendelle")
new_monstropolis = graph.add_node("New Monstropolis")
naboo = graph.add_node("Naboo")
narnia = graph.add_node("Narnia")
graph.add_edge(pandora, arendelle, 150)
graph.add_edge(arendelle, pandora, 150)
graph.add_edge(pandora, metroville, 82)
graph.add_edge(metroville, pandora, 82)
graph.add_edge(metroville, arendelle, 99)
graph.add_edge(arendelle, metroville, 99)
graph.add_edge(new_monstropolis, arendelle, 42)
graph.add_edge(arendelle, new_monstropolis, 42)
graph.add_edge(new_monstropolis, metroville, 105)
graph.add_edge(metroville, new_monstropolis, 105)
graph.add_edge(new_monstropolis, naboo, 73)
graph.add_edge(naboo, new_monstropolis, 73)
graph.add_edge(metroville, naboo, 26)
graph.add_edge(naboo, metroville, 26)
graph.add_edge(metroville, narnia, 37)
graph.add_edge(narnia, metroville, 37)
graph.add_edge(narnia, naboo, 250)
graph.add_edge(naboo, narnia, 250)
return graph
def topological_sort(graph: Graph) -> None:
visited = set()
stack = Stack()
for vertex in graph.adjacency_list:
if vertex not in visited:
_topological_sort(graph, vertex, visited, stack)
print(stack)
def _topological_sort(graph: Graph, vertex: Any, visited: Set, stack: Stack) -> None:
visited.add(vertex)
for neighbor in graph.adjacency_list[vertex]:
if neighbor[0] not in visited:
_topological_sort(graph, neighbor[0], visited, stack)
stack.push(vertex)
if __name__ == '__main__':
graph = Graph()
graph.add_edge(5, 2)
graph.add_edge(5, 0)
graph.add_edge(2, 3)
graph.add_edge(3, 1)
graph.add_edge(4, 1)
graph.add_edge(4, 0)
topological_sort(graph)
