def test_add():
mary = GraphNode.GraphNode('Mary')
june = GraphNode.GraphNode('June')
mary.add_path(june, 'cast away')
assert len(mary.edges) == 1
assert len(june.edges) == 0
june.add_path(mary, 'cast away')
assert len(june.edges) == 1
kevin = GraphNode.GraphNode('Kevin')
june.add_path(kevin, 'cast away')
assert len(june.edges) == 2
assert len(kevin.edges) == 0
kevin.add_path(june, 'cast away')
assert len(kevin.edges) == 1
amber = GraphNode.GraphNode('Amber')
kevin.add_path(amber, 'pretty woman')
amber.add_path(kevin, 'pretty woman')
assert len(june.edges) == 2
assert len(kevin.edges) == 2
assert len(mary.edges) == 1
assert len(amber.edges) == 1
mary.add_path(kevin, 'cast away')
kevin.add_path(mary, 'cast away')
assert len(mary.edges) == 2
assert len(kevin.edges) == 3
def df_topo(node: GraphNode, node_list: GraphNode):
if node.found:
return node_list
node.found = True
for neighbor in node.get_neighbors():
node_list = df_topo(neighbor, node_list)
node.next_node = node_list
return node
def add_path(self, actor1, actor2, movie):
if actor1 in self.nodes:
actor_node1 = self.nodes[actor1]
else:
actor_node1 = GraphNode.GraphNode(actor1)
if actor2 in self.nodes:
actor_node2 = self.nodes[actor2]
else:
actor_node2 = GraphNode.GraphNode(actor2)
actor_node1.add_path(actor_node2, movie)
actor_node2.add_path(actor_node1, movie)
self.nodes[actor1] = actor_node1
self.nodes[actor2] = actor_node2
def createLinkedList(n):
graph = WeightedGraph.WeightedGraph()
for i in range(0, n):
node = GraphNode(i)
if i > 0:
graph.addWeightedEdge(graph.verticies[-1], node, 1)
graph.verticies.append(node)
return graph
def add_direct_path(self, actor1, actor2, movie):
# path from actor1 to actor2
if actor1 in self.nodes:
node1 = self.nodes[actor1]
else:
node1 = GraphNode.GraphNode(actor1)
if actor2 in self.nodes:
node2 = self.nodes[actor2]
else:
node2 = GraphNode.GraphNode(actor2)
node1.add_path(node2, movie)
self.nodes[actor1] = node1
self.nodes[actor2] = node2
def create_sents_graph(self, sents):
graph = Graph('undirected')
# add vertices
# use original sentence location as vertex
for i in range(len(sents)):
graph.add_vertex(i)
# add edges
for i in range(len(sents)):
sentI_len = len(sents[i])
for j in range(i+1, len(sents)):
sentJ_len = len(sents[j])
common_words_len = len([ word for word in sents[i] if word in set(sents[j]) ])
if(common_words_len > 0):
simm_score = common_words_len/(1 + math.log(sentI_len, 2) + math.log(sentJ_len, 2))
graph.add_edge(GraphNode(i), GraphNode(j), simm_score)
return graph
def createRandomCompleteWeightedGraph(n):
graph = WeightedGraph.WeightedGraph()
for i in range(0, n):
node = GraphNode(i)
graph.verticies.append(node)
for x in graph.verticies:
for y in graph.verticies:
rng = random.randint(0, sys.maxsize - 1)
if x != y:
graph.addWeightedEdge(x, y, rng)
return graph
def bfs(graph: Graph, from_node: GraphNode):
# Reset nodes
for node in graph.nodes:
node.dist = -1
node.predecessor = None
from_node.dist = 0
queue = Queue()
queue.enqueue(from_node)
while not queue.empty():
current_node = queue.dequeue()
# print("Current node: {}".format(current_node.label))
for neighbor in current_node.get_neighbors():
# print(" Neighbor: {}".format(neighbor.label))
if neighbor.dist < 0:
neighbor.dist = current_node.dist + 1
neighbor.predecessor = current_node
queue.enqueue(neighbor)
def main():
node_a = GraphNode("A")
node_b = GraphNode("B")
node_c = GraphNode("C")
node_d = GraphNode("D")
node_e = GraphNode("E")
node_f = GraphNode("F")
node_a.update_neighbours([node_b, node_e, node_f])
node_b.update_neighbours([node_e])
node_c.update_neighbours([node_b])
node_d.update_neighbours([node_c, node_e])
node_f.update_neighbours([node_b])
print(has_route(node_f, node_e))
def dfs(node, visited, sorted_graph):
# time = time + 1
# node.start = time
visited.add(node)
for child in node.children:
if child not in visited:
# traverse the child
dfs(child, visited, sorted_graph)
else:
if child not in sorted_graph:
raise Exception("Error, there is a loop")
# time = time + 1
# node.finish = time
sorted_graph.insert(0, node)
graph = Graph()
node_a = GraphNode("a")
node_b = GraphNode("b")
node_c = GraphNode("c")
node_d = GraphNode("d")
node_e = GraphNode("e")
node_f = GraphNode("f")
node_a.children = [node_d]
node_b.children = [node_d]
node_f.children = [node_a, node_b]
node_d.children = [node_c]
graph.nodes = [node_a, node_b, node_c, node_d, node_e, node_f]
res = topological_sort(graph)
print(res)
queue = deque()
queue.append(start_node)
while len(queue) > 0:
current_node = queue.popleft() #dequeue
visited.add(current_node)
if current_node.label == search_label:
return current_node
for edge in current_node.edges:
if edge.target_node not in visited:
queue.append(edge.target_node) #enqueue
if __name__ == '__main__':
nodeG = GraphNode('G')
nodeR = GraphNode('R')
nodeA = GraphNode('A')
nodeP = GraphNode('P')
nodeH = GraphNode('H')
nodeS = GraphNode('S')
graph1 = Graph([nodeS, nodeH, nodeG, nodeP, nodeR, nodeA])
graph1.add_edge(nodeG, nodeR)
graph1.add_edge(nodeA, nodeR)
graph1.add_edge(nodeA, nodeG)
graph1.add_edge(nodeR, nodeP)
graph1.add_edge(nodeH, nodeG)
graph1.add_edge(nodeH, nodeP)
graph1.add_edge(nodeS, nodeR)
def addNode(self, nodeVal):
node = GraphNode(nodeVal)
self.verticies.append(node)
def test_topological_sort(self):
self.graph = Graph()
node_undershorts = GraphNode("undershorts")
node_pants = GraphNode("pants")
node_belt = GraphNode("belt")
node_shirt = GraphNode("shirt")
node_tie = GraphNode("tie")
node_jacket = GraphNode("jacket")
node_socks = GraphNode("socks")
node_shoes = GraphNode("shoes")
node_watch = GraphNode("watch")
node_undershorts.children = [node_pants, node_shoes]
node_pants.children = [node_shoes, node_belt]
node_belt.children = [node_jacket]
node_shirt.children = [node_belt, node_tie]
node_tie.children = [node_jacket]
node_socks.children = [node_shoes]
self.graph.nodes = [
node_undershorts, node_pants, node_belt, node_shirt, node_tie,
node_jacket, node_socks, node_shoes, node_watch
]
self.assertEqual(self.graph.topological_sort(), [
'watch', 'socks', 'shirt', 'tie', 'undershorts', 'pants', 'belt',
'jacket', 'shoes'
])
def test_bi_directional_search(self):
self.graph = Graph()
node_0 = GraphNode(0)
node_1 = GraphNode(1)
node_2 = GraphNode(2)
node_3 = GraphNode(3)
node_4 = GraphNode(4)
node_5 = GraphNode(5)
node_6 = GraphNode(6)
node_0.children = [node_1, node_4, node_5]
node_1.children = [node_3, node_4]
node_2.children = [node_1, node_6]
node_3.children = [node_2]
node_4.children = [node_3]
self.graph.nodes = [
node_0, node_1, node_2, node_3, node_4, node_5, node_6
]
self.assertEqual(
self.graph.bi_directional_search(self.graph.nodes[0],
self.graph.nodes[6]),
[0, 1, 3, 2, 6], "path 0->6")
self.assertEqual(
self.graph.bi_directional_search(self.graph.nodes[0],
self.graph.nodes[2]),
[0, 1, 3, 2], "path 0->2")
def init_graph(self):
self.graph = Graph()
node_0 = GraphNode(0)
node_1 = GraphNode(1)
node_2 = GraphNode(2)
node_3 = GraphNode(3)
node_4 = GraphNode(4)
node_5 = GraphNode(5)
node_0.children = [node_1, node_4, node_5]
node_1.children = [node_3, node_4]
node_2.children = [node_1]
node_3.children = [node_2, node_4]
self.graph.nodes = [node_0, node_1, node_2, node_3, node_4, node_5]
def test_shortest_path(self):
self.graph = Graph()
node_0 = GraphNode(0)
node_1 = GraphNode(1)
node_2 = GraphNode(2)
node_3 = GraphNode(3)
node_4 = GraphNode(4)
node_0.children = [node_1, node_3]
node_0.child_weights = [2, 1]
node_1.children = [node_2]
node_1.child_weights = [2]
node_2.children = [node_4]
node_2.child_weights = [4]
node_3.children = [node_4]
node_3.child_weights = [1]
node_4.children = [node_2]
node_4.child_weights = [1]
self.graph.nodes = [node_0, node_1, node_2, node_3, node_4]
self.assertEqual(self.graph.shortest_path(0), [-1, 0, 4, 0, 3])