def main():
g0 = UndirectedGraph()
g0.addVertex(1)
g0.addVertex(2)
g0.addVertex(3)
g0.addEdge((1, 2))
g0.addEdge((1, 3))
print(g0)
x = g0.isTree(1, {})
if x:
print("g0 is a tree")
else:
print("g0 is not a tree")
print("\n")
g0.addVertex(4)
g0.addEdge((3, 4))
print(g0)
x = g0.isTree(1, {})
if x:
print("g0 is a tree")
else:
print("g0 is not a tree")
print("\n")
g0.addEdge((2, 4))
print(g0)
x = g0.isTree(1, {})
if x:
print("g0 is a tree")
else:
print("g0 is not a tree")
print("\n")
g1 = UndirectedGraph()
g1.addVertex(1)
g1.addVertex(2)
g1.addVertex(3)
g1.addVertex(4)
g1.addVertex(5)
g1.addEdge((1, 2))
g1.addEdge((1, 3))
g1.addEdge((2, 4))
g1.addEdge((2, 5))
g1.addEdge((4, 5))
print(g1)
x = g1.isTree(1, {})
if x:
print("g1 is a tree")
else:
print("g1 is not a tree")
def setUp(self):
self.graph = UndirectedGraph()
self.filled_graph = UndirectedGraph()
for i in range(6):
self.filled_graph.add_vertex(i + 1)
self.filled_graph.add_edge(1, 2)
self.filled_graph.add_edge(1, 4)
self.filled_graph.add_edge(2, 4)
self.filled_graph.add_edge(2, 3)
self.filled_graph.add_edge(4, 3)
self.filled_graph.add_edge(3, 6)
self.filled_graph.add_edge(4, 5)
self.filled_graph.add_edge(5, 6)
def test_ugraph_edges(self):
# Checks for antisimetry
g = UndirectedGraph.rand(5)
self.assertTrue(g.is_antisymmetric())
with self.assertRaises(IsNotUndirectedGraphError):
UndirectedGraph(3, [[0, 0], [0, 2], [2, 0], [1, 0]])
def test_load_graph_duplicate_non_conflicting_lines(self):
try:
UndirectedGraph(
"test/graph-with-duplicate-non-conflicting-lines.csv")
except ValueError:
self.fail(
"Graph file contains duplicate, but non-conflicting edges.")
def test_adj(self):
graph = UndirectedGraph(5, [(0, 1), (2, 3), (0, 4)])
self.assertEqual(graph.adj(0), [1, 4])
self.assertEqual(graph.adj(1), [0])
self.assertEqual(graph.adj(2), [3])
self.assertEqual(graph.adj(3), [2])
self.assertEqual(graph.adj(4), [0])
def test_adjacency_matrix(self):
ug = UndirectedGraph("A", "B", "C", "D")
ug.add_new_edge("A", "B")
ug.add_new_edge("B", "C")
ug.add_new_edge("C", "D")
assert ug.adjacency_matrix == [[0, 1, 0, 0], [1, 0, 1, 0],
[0, 1, 0, 1], [0, 0, 1, 0]]
def from_networkx(ngraph):
if ngraph.is_directed():
raise NotImplementedError()
else:
graph = UndirectedGraph(ngraph.number_of_nodes())
for edge in ngraph.edges_iter():
graph.add_edge(int(edge[0]), int(edge[1]))
return graph
def journeyToMoon(n, astronaut):
'''
Function signature supplied by Hackerrank,
and my implementation using supplied arguments: n, astronaut.
'''
graph = UndirectedGraph(n, astronaut)
subset_sizes = disjoint_subset_sizes(graph)
return number_of_pairs(subset_sizes)
def test_degeneracy_ordering_nonempty(adjacencies: List[Set[Vertex]]) -> None:
g = UndirectedGraph(adjacencies=adjacencies)
connected_vertices = g.connected_vertices()
ordering = list(degeneracy_ordering(g))
assert set(ordering) == connected_vertices
assert all(g.degree(ordering[0]) <= g.degree(v) for v in ordering[1:])
ordering_min1 = list(degeneracy_ordering(g, drop=1))
assert ordering_min1 == ordering[:-1]
def test_find_shortest_path(self):
dg = UndirectedGraph("A", "B", "C", "D")
dg.add_new_edge("A", "B")
dg.add_new_edge("B", "D")
dg.add_new_edge("B", "C")
dg.add_new_edge("A", "C")
dg.add_new_edge("C", "D")
result = dg.find_shortest_path("A", "D")
assert result == [vt("A"), vt("B"), vt("D")] or result == [
vt("A"), vt("C"), vt("D")
]
def random_undirected_graph(order: int, size: int) -> UndirectedGraph:
adjacencies: List[Set[Vertex]] = [set() for _ in range(order)]
print(f"order={order}, size={size}")
for v, w in generate_n_edges(order, size):
adjacencies[v].add(w)
adjacencies[w].add(v)
print(adjacencies)
g = UndirectedGraph(adjacencies=adjacencies)
assert g.order == order
assert g.size() == size
return g
def test_simple(self):
graph = UndirectedGraph(4)
graph.add(0, 1, 10)
graph.add(0, 2, 4)
graph.add(1, 2, 5)
graph.add(1, 3, 6)
graph.add(2, 3, 5)
value = stoer_wagner(graph)
expected_value = 11 # (0, 1, 2) & 3
self.assertEqual(value, expected_value)
def test_create(self):
ug = UndirectedGraph("A", "B", "C")
ug.add_new_edge("A", "B")
ug.add_new_edge("B", "C")
assert [v.name for v in ug.vertexes] == ["A", "B", "C"]
assert ug.adjacency_dict == {
vt("A"): [vt("B")],
vt("B"): [vt("A"), vt("C")],
vt("C"): [vt("B")]
}
with pytest.raises(exceptions.VertexNotExistError):
ug.get_vertex_by_name("E")
with pytest.raises(exceptions.VertexNotExistError):
ug.add_new_edge("C", "E")
def main():
graph_filename = input("Graph filename: ")
graph = UndirectedGraph(graph_filename)
start_node = input("Start node: ")
end_node = input("End node: ")
shortest_path = graph.shortest_path(start_node, end_node)
path = shortest_path['path']
cost = shortest_path['cost']
if path is None:
print(f"There is no path connecting {start_node} to {end_node}.")
else:
print(
f"Path from {start_node} to {end_node} is {path_to_string(path)},",
f"and have cost {cost}.")
def test_traverse(self):
vertexes_names = []
def traverse_visit_callback(vertex):
vertexes_names.append(vertex.name)
un = UndirectedGraph("A", "B", "C", "D")
un.add_new_edge("A", "B")
un.add_new_edge("B", "C")
un.add_new_edge("C", "D")
# bfs
un.bfs_traverse("A", traverse_visit_callback)
assert vertexes_names == ["A", "B", "C", "D"]
vertexes_names = []
# dfs
un.dfs_traverse("A", traverse_visit_callback)
assert vertexes_names == ["A", "B", "C", "D"]
def test_simple(self):
graph = UndirectedGraph(5)
graph.add(0, 1, 7)
graph.add(0, 2, 3)
graph.add(0, 3, 2)
graph.add(0, 4, 6)
graph.add(1, 2, 9)
graph.add(1, 3, 4)
graph.add(1, 4, 8)
graph.add(2, 3, 4)
graph.add(2, 4, 5)
graph.add(3, 4, 5)
min_tree_weight, tree_edges = prim(graph)
expected_min_weight = 14
self.assertEqual(expected_min_weight, min_tree_weight)
def read_random_graph(orderstr: str,
size: Optional[int]) -> Tuple[UndirectedGraph, int]:
order = to_int(orderstr)
fully_meshed_size = order * (order - 1) // 2
if size is None:
size = fully_meshed_size
elif size > fully_meshed_size:
raise ValueError(
f"{order} nodes accommodate at most {fully_meshed_size} edges")
edges_name = f"random_edges_order_{orderstr}"
stats_name = f"random_stats"
edges_path = os.path.join(os.pardir, "data", edges_name + ".txt")
stats_path = os.path.join(os.pardir, "data", stats_name + ".txt")
adjacencies = read_edges(edges_path, orderstr, order, size)
clique_count = read_stats(stats_path, orderstr, size)
g = UndirectedGraph(adjacencies=adjacencies)
assert g.order == order
assert g.size() == size
return g, clique_count
def testIndependentSet(self):
n = 100
e = 5 * n
g = UndirectedGraph()
for i in range(e):
u = int(random() * n)
v = int(random() * n)
if u == v:
continue
if not g.contains(u):
g.add_node(u)
if not g.contains(v):
g.add_node(v)
g.connect(u, v)
ind_set = g.independent_set(8)
for i in ind_set:
neighbors = g.e[i]
self.assertEqual(neighbors.intersection(ind_set), set([]))
def build_graph(adj, features, labels):
edges = np.array(adj.nonzero()).T
y_values = np.array(labels.nonzero()).T
domain_labels = []
for i in range(labels.shape[1]):
domain_labels.append("c" + str(i))
# create graph
graph = UndirectedGraph()
id_obj_map = []
for i in range(adj.shape[0]):
n = Node(i, features[i, :], domain_labels[y_values[i, 1]])
graph.add_node(n)
id_obj_map.append(n)
for e in edges:
graph.add_edge(Edge(id_obj_map[e[1]], id_obj_map[e[0]]))
return graph, domain_labels
def setUp(self):
self.graph = UndirectedGraph("graph.csv")
def test_degeneracy_ordering_empty() -> None:
g = UndirectedGraph(adjacencies=[])
assert list(degeneracy_ordering(g)) == []
assert list(degeneracy_ordering(g, drop=1)) == []
def dfs_iterative(graph, start_node):
visited = [start_node]
stack = [start_node]
print('Visited', start_node)
while stack != []:
popped = stack.pop()
if popped not in visited:
print('Visited', popped)
visited.append(popped)
for node in graph.adjacents(popped):
if node not in visited:
stack.append(node)
if __name__ == '__main__':
g = UndirectedGraph()
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(0, 3)
g.add_edge(1, 4)
g.add_edge(1, 5)
g.add_edge(2, 6)
g.add_edge(2, 7)
g.add_edge(3, 7)
bfs(g, 0)
print('=' * 50)
dfs(g, 0)
print('=' * 50)
dfs_iterative(g, 0)
def remove_independent_set(regions):
"""
Processes a set of regions, detecting and removing an independent set
of vertices from the regions' graph representation, and re-triangulating
the resulting holes.
Arguments:
regions -- a set of non-overlapping polygons that tile some part of the plane
Returns: a new set of regions covering the same subset of the plane, with fewer vertices
"""
# Take note of which points are in which regions
points_to_regions = {}
for idx, region in enumerate(regions):
for point in region.points:
if point in points_to_regions:
points_to_regions[point].add(idx)
continue
points_to_regions[point] = set([idx])
# Connect graph
g = UndirectedGraph()
for region in regions:
for idx in range(region.n):
u = region.points[idx % region.n]
v = region.points[(idx + 1) % region.n]
if not g.contains(u):
g.add_node(u)
if not g.contains(v):
g.add_node(v)
g.connect(u, v)
# Avoid adding points from outer triangle
removal = g.independent_set(8, avoid=bounding_triangle.points)
# Track unaffected regions
unaffected_regions = set([i for i in range(len(regions))])
new_regions = []
for p in removal:
# Take note of affected regions
affected_regions = points_to_regions[p]
unaffected_regions.difference_update(points_to_regions[p])
def calculate_bounding_polygon(p, affected_regions):
edges = []
point_locations = {}
for j, i in enumerate(affected_regions):
edge = set(regions[i].points)
edge.remove(p)
edges.append(edge)
for v in edge:
if v in point_locations:
point_locations[v].add(j)
else:
point_locations[v] = set([j])
boundary = []
edge = edges.pop()
for v in edge:
point_locations[v].remove(len(edges))
boundary.append(v)
for k in range(len(affected_regions) - 2):
v = boundary[-1]
i = point_locations[v].pop()
edge = edges[i]
edge.remove(v)
u = edge.pop()
point_locations[u].remove(i)
boundary.append(u)
return shapes.Polygon(boundary)
# triangulate hole
poly = calculate_bounding_polygon(p, affected_regions)
triangles = spatial.triangulatePolygon(poly)
for triangle in triangles:
self.dag.add_node(triangle)
for j in affected_regions:
region = regions[j]
self.dag.connect(triangle, region)
new_regions.append(triangle)
for i in unaffected_regions:
new_regions.append(regions[i])
return new_regions
self._marked[a] = True
self.queue.append(a)
def has_path_to(self, v: int):
return self._marked[v]
def path_to(self, v: int):
if self.has_path_to(v) == False: return None
path = []
x = v
while x != self._s:
path.append(x)
x = self._edgeto[x]
path.append(self._s)
for i in reversed(path):
print(f"{i}->", end='')
def marked(self, v: int):
return self._marked[v]
G1 = UndirectedGraph(5)
G1.add_edge(0, 1)
G1.add_edge(1, 2)
G1.add_edge(2, 3)
print(G1)
bfs = BFS(G1, 0)
print(bfs.has_path_to(3))
print(bfs.path_to(4))
print(bfs.path_to(3))
from server import *
from graph import UndirectedGraph # assumes we use the graph module from class
#test10(29577354,29577354)
rgraph = read_city_graph("edmonton-roads-2.0.1.txt") # read data
cost_distance(29577354, 29577354)
graph = UndirectedGraph({1, 2, 3, 4, 5, 6}, [(1, 2), (1, 3), (1, 6), (2, 1),
(2, 3), (2, 4), (3, 1), (3, 2),
(3, 4), (3, 6), (4, 2), (4, 3),
(4, 5), (5, 4), (5, 6), (6, 1),
(6, 3), (6, 5)])
weights = {
(1, 2): 7,
(1, 3): 9,
(1, 6): 14,
(2, 1): 7,
(2, 3): 10,
(2, 4): 15,
(3, 1): 9,
(3, 2): 10,
(3, 4): 11,
(3, 6): 2,
(4, 2): 15,
(4, 3): 11,
(4, 5): 6,
(5, 4): 6,
(5, 6): 9,
(6, 1): 14,
(6, 3): 2,
(6, 5): 9
}
def __init__(self, V):
self.weights = UndirectedGraph(V)
self.units = numpy.random.random(V) < 0.5
self.biases = numpy.zeros(V)
# tests are files that have the 'in' extension
if test.endswith('.in') is False:
continue
print(f'\nSolving {test}')
# read the file
with open(f'./tests/{test}', 'r') as f:
n = int(f.readline().strip())
m = int(f.readline().strip())
# make sure the test is valid
assert n > 0, 'Number of nodes is invalid'
# I can have a maximum number of edges of n*(n-1)/2
assert m <= n * (n - 1) / 2, 'Number of edges is too big'
# create our graph
g = UndirectedGraph(n, {})
for _ in range(m):
line = f.readline().strip()
a, b = [int(x) for x in line.split(' ')]
g.add_edge(a, b)
# print(g)
# answer the questions
f_out = open('./tests/' + test.replace('.in', '.out'), 'w')
no_queries = int(f.readline().strip())
for _ in range(no_queries):
line = f.readline().strip()
a, b = [int(x) for x in line.split(' ')]
res = g.get_shortest_path(a, b)
assert res == g.get_shortest_path_simple_bfs(
def test_load_graph_conflicting_lines(self):
with self.assertRaises(ValueError):
UndirectedGraph("test/graph-with-conflicting-lines.csv")
def test_calculation(self):
graph = UndirectedGraph(5, [(0, 1), (2, 3), (0, 4)])
self.assertEqual(disjoint_subset_sizes(graph), [3, 2])
def test_create_exceptions(self):
with self.assertRaises(TypeError):
graph = UndirectedGraph(None, [(0, 1), (2, 3), (0, 4)])
with self.assertRaises(TypeError):
graph = UndirectedGraph(4, None)
