def random_weighted_graph_resolver(data, _): def random_matrix(size, p): adj_matrix = [['.'] * size for i in range(size)] for i in range(size): for j in range(i, size): if i != j and random.random() < p: # 0.4 - probability that edge between i and j exists adj_matrix[i][j] = adj_matrix[j][i] = 1 return adj_matrix size = int(data.split(' ')[0]) p = float(data.split(' ')[1]) if size < 0: return "Size cannot be a negative number" matrix = random_matrix(size, p) graph = Graph.from_cost_matrix(matrix) components = Algorithms.max_connected_comp(graph) while len(components) > 1: matrix = random_matrix(size, p) graph = Graph.from_cost_matrix(matrix) components = Algorithms.max_connected_comp(graph) for i in range(size): for j in range(i, size): if matrix[i][j] == 1: matrix[i][j] = matrix[j][i] = random.randrange(1, 11) s = "" for row in matrix: s += f"{' '.join([f' {cell}' if len(str(cell)) == 1 else f'{cell}' for cell in row])}\n" return s
def hamilton_cycle_resolver(graph: Graph, args): result = Algorithms.hamiltonian_cycle(graph) if result is None: return 'Given graph does not have an hamiltonian cycle' else: return result
def kruskal_resolver(graph, _): minimal_spanning_tree = Algorithms.kruskal(graph) result_str = "" for row in minimal_spanning_tree: result_str += f"{' '.join([f' {cell}' if len(str(cell)) == 1 else f'{cell}' for cell in row])}\n" return result_str
def distance_matrix_resolver(graph, _): result = Algorithms.distance_matrix(graph) s = "" for row in result: s += f"{' '.join([f' {cell}' if len(str(cell)) == 1 else f'{cell}' for cell in row])}\n" return s
def create_random_eulerian_resolver(data, _): nodes = int(data) eulerian_graph = Algorithms.create_random_eulerian(nodes) adjacency_list = AdjacencyList(eulerian_graph) print(Graph.from_adjacency_list(adjacency_list)) euler_cycle = AdjacencyList.find_euler_path(adjacency_list, Node(0)) return euler_cycle
def graphical_sequence(): data = input('Enter number sequence:\n') sequence = [int(number) for number in data.split(' ')] graph = Algorithms.degree_seq_to_graph(sequence) if graph is None: raise Error("Given sequence does not represent a valid graph") return graph
def k_regular_graph_resolver(args, _): [nodes, degree] = [int(num) for num in args.split(' ')] result = Algorithms.generate_random_regular_graph(degree, nodes) graph = Graph() adj_matrix = AdjacencyMatrix(graph) adj_matrix.matrix = result return adj_matrix
def johnson_resolver(graph, _): try: result = Algorithms.johnson(graph) result_str = "" for row in result: result_str += f"{' '.join([f' {cell}' if len(str(cell)) == 1 else f'{cell}' for cell in row])}\n" return result_str except Exception as e: return str(e)
def max_connected_comp_resolver(graph: Graph, args): components = Algorithms.max_connected_comp(graph) result = "" max_component_index = 0 for i, component in enumerate(components): result += f"{i}) {component}\n" if len(component) == max([len(comp) for comp in components]): max_component_index = i result += f"Largest component have an index of {max_component_index}\n" return result
def dijkstra_resolver(graph, _): d_s, p_s = Algorithms.dijkstra(graph, 0) result = "" for node, distance in enumerate(d_s): prev = p_s[node] path = [str(node)] while prev is not None: path.append(str(prev)) prev = p_s[prev] path.reverse() result += f"d({node}) = {distance}, path: [{' - '.join(path)}]\n" return result
def center_resolver(graph, _): center, min_row_sum = Algorithms.graph_center(graph) center_minimax, minimax_distance = Algorithms.graph_minimax_center(graph) return f"center node id: {center} with sum of {min_row_sum}\nminimax center node id: {center_minimax} with minimax distance of {minimax_distance}\n"