def bridge(G, v, u):
G[v][u] = 0
G[u][v] = 0
components = Components()
[comp, nr] = components.find_components(G)
G[v][u] = 1
G[u][v] = 1
if comp[v] != comp[u]:
return True
else:
return False
def test_find_comp():
print("\nTask 3: Connected components:\n")
G = [[0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0]]
components = Components()
[comp, nr] = components.find_components(G)
comp_lists = [[] for x in range(nr)]
for v in range(len(G)):
comp_lists[comp[v] - 1].append(v)
for count, item in enumerate(comp_lists):
print(count + 1, item)
print("Biggest connected component: " + str(components.max_component))
print("has " + str(components.max_count) + " vertices")
def choose_biggest_comp(self):
adjacency = self.adj.tolist()
components = Components()
[comp, nr] = components.find_components(adjacency)
for v in range(self.n):
if comp[v] == components.max_component:
self.biggest_comp.append(v)
for i in reversed(range(self.n)):
if i not in self.biggest_comp:
adjacency.pop(i)
else:
for j in reversed(range(self.n)):
if j not in self.biggest_comp:
adjacency[i].pop(j)
self.n -= (self.n - len(self.biggest_comp))
self.adj = np.array(adjacency)
def choose_biggest_comp(G):
biggest_comp = []
components = Components()
[comp, nr] = components.find_components(G.adjacency)
adj = G.adjacency.tolist()
for v in range(G.size):
if comp[v] == components.max_component:
biggest_comp.append(v)
for i in reversed(range(G.size)):
if i not in biggest_comp:
adj.pop(i)
else:
for j in reversed(range(G.size)):
if j not in biggest_comp:
adj[i].pop(j)
G.size -= (G.size - len(biggest_comp))
G.adjacency = np.array(adj)
def main():
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument('-s',
'--sequence',
action='store_true',
help='''Check if given sequence is graphic. Sequence
consisting of ints separated by spaces''')
group.add_argument(
'-r',
'--randomize',
action='store_true',
help='''Randomize edges n times where n(int) is first parameter
after -r/--randomize flag
in graph given by the graphical sequence(ints separated by
spaces)''')
group.add_argument('-c',
'--components',
action='store_true',
help='''Find all connected components
in graph given by the graphical sequence(ints separated by
spaces) and mark the greatest''')
group.add_argument(
'-e',
'--euler',
action='store_true',
help='''Make random Euler's graph with given n(int) nodes or
with random number of them if not specified''')
group.add_argument(
'-kr',
'--regular',
action='store_true',
help='''Make k-regular graph with n nodes where n(int) is first
parameter and k(int) the second one''')
group.add_argument(
'-H',
'--hamilton',
action='store_true',
help='''Check Hamilton's cycle exists in graph given by the
graphical sequence(ints separated by spaces) and prints it'''
)
arg = parser.parse_known_args()
if arg[0].sequence:
parser2 = argparse.ArgumentParser()
parser2.add_argument('seq', type=int, nargs='+')
args = parser2.parse_args(arg[1])
try:
g = Graph.from_sequence(np.array(args.seq))
g.show()
except NotGraphicSequenceException:
print(f"Sequence:\n{args.seq}\nis not a graphic sequence")
return
return
if arg[0].randomize:
parser2 = argparse.ArgumentParser()
parser2.add_argument('n', type=int)
parser2.add_argument('seq', type=int, nargs='+')
args = parser2.parse_args(arg[1])
if args.n < 0:
print('Number of randomization n must be positive integer ')
return
try:
g = Graph.from_sequence(np.array(args.seq))
except NotGraphicSequenceException:
print(f"Sequence:\n{args.seq}\nis not a graphic sequence")
return
print("Randomized edges:")
for i in range(0, args.n):
p1, p2 = g.randomize_edges()
print(f"{p1}, {p2} => ({p1[0]}, {p2[1]}), ({p1[1]}, {p2[0]})")
print()
g.show()
return
if arg[0].components:
parser2 = argparse.ArgumentParser()
parser2.add_argument('seq', type=int, nargs='+')
args = parser2.parse_args(arg[1])
try:
g = Graph.from_sequence(np.array(args.seq))
except NotGraphicSequenceException:
print(f"Sequence:\n{args.seq}\nis not a graphic sequence")
return
G = g.adjacency
components = Components()
[comp, nr] = components.find_components(G)
comp_lists = [[] for x in range(nr)]
for v in range(len(G)):
comp_lists[comp[v] - 1].append(v)
for count, item in enumerate(comp_lists):
print(count + 1, item)
print("Biggest connected component: " + str(components.max_component))
print("has " + str(components.max_count) + " vertices")
return
if arg[0].euler:
parser2 = argparse.ArgumentParser()
parser2.add_argument('n',
type=int,
nargs='?',
default=random.randint(4, 30))
args = parser2.parse_args(arg[1])
find_euler_random(args.n)
return
if arg[0].regular:
print(5)
parser2 = argparse.ArgumentParser()
parser2.add_argument('n', type=int)
parser2.add_argument('k', type=int)
args = parser2.parse_args(arg[1])
gen_k_regular(args.n, args.k)
return
if arg[0].hamilton:
parser2 = argparse.ArgumentParser()
parser2.add_argument('seq', type=int, nargs='+')
args = parser2.parse_args(arg[1])
try:
g = Graph.from_sequence(np.array(args.seq))
except NotGraphicSequenceException:
print(f"Sequence:\n{args.seq}\nis not a graphic sequence")
return
adj_list = convert_matrix_to_adj_list(g.adjacency)
print(adj_list)
check_hamilton_cycle(adj_list)
return
