SAKOD_lab5.py

#!/usr/bin/env python3
# \author: Артюхин Матфей
# \date_start: 2025-03-29
# \date_end: 2025-04-3

class Graph:
    """
    \brief Класс для представления графа и работы с матрицами смежности и инцидентности.

    \param vertices [in] - список названий вершин
    \param edges [in]    - словарь ребер вида {название: (вершина1, вершина2, вес)}
    """
    def __init__(self):
        self.vertices = []
        self.edges = {}

    def add_vertex(self, name):
        """
        \brief Добавление вершины в граф.

        \param name [in] - название вершины
        """
        if name in self.vertices:
            print(f"Ошибка: вершина '{name}' уже существует!")
            return
        self.vertices.append(name)

    def add_edge(self, name, v1, v2, weight):
        """
        \brief Добавление ребра в граф.

        \param name [in]   - название ребра
        \param v1 [in]    - первая вершина
        \param v2 [in]    - вторая вершина
        \param weight [in] - вес ребра
        """
        if name in self.edges:
            print(f"Ошибка: ребро '{name}' уже существует!")
            return
        if v1 not in self.vertices or v2 not in self.vertices:
            print("Ошибка: указанная вершина не существует!")
            return
        self.edges[name] = (v1, v2, weight)

    def adjacency_matrix(self):
        """
        \brief Построение матрицы смежности.

        \retval list - матрица смежности с весами
        """
        size = len(self.vertices)
        matrix = [[0] * size for _ in range(size)]
        idx = {v: i for i, v in enumerate(self.vertices)}

        for edge in self.edges.values():
            i = idx[edge[0]]
            j = idx[edge[1]]
            matrix[i][j] = edge[2]
            matrix[j][i] = edge[2]  # для ненаправленного графа
        return matrix

    def incidence_matrix(self):
        """
        \brief Построение матрицы инцидентности.

        \retval list - матрица инцидентности с весами
        """
        size_v = len(self.vertices)
        size_e = len(self.edges)
        matrix = [[0] * size_e for _ in range(size_v)]
        idx_v = {v: i for i, v in enumerate(self.vertices)}
        idx_e = {e: i for i, e in enumerate(self.edges)}

        for i, (edge_name, edge_data) in enumerate(self.edges.items()):
            v1, v2, weight = edge_data
            matrix[idx_v[v1]][i] = weight
            matrix[idx_v[v2]][i] = weight
        return matrix

    def print_matrix(self, matrix, title, row_labels, col_labels):
        """
        \brief Форматированный вывод матрицы.

        \param matrix [in]     - матрица для вывода
        \param title [in]      - заголовок
        \param row_labels [in] - метки строк
        \param col_labels [in] - метки столбцов
        \retval None
        """
        print(f"\n{title}:")
        # Шапка с названиями ребер/вершин
        header = "\t" + "\t".join(col_labels)
        print(header)
        # Тело матрицы
        for i, row in enumerate(matrix):
            line = f"{row_labels[i]}\t" + "\t".join(map(str, row))
            print(line)

def main():
    """
    \brief Основная функция для ввода данных и вывода результатов.
    """
    graph = Graph()

    # Ввод вершин
    n_vertices = int(input("Количество вершин: "))
    for _ in range(n_vertices):
        name = input("Название вершины: ").strip()
        graph.add_vertex(name)

    # Ввод ребер
    n_edges = int(input("Количество ребер: "))
    for _ in range(n_edges):
        name = input("Название ребра: ").strip()
        v1 = input("Первая вершина: ").strip()
        v2 = input("Вторая вершина: ").strip()
        weight = float(input("Вес ребра: "))
        graph.add_edge(name, v1, v2, weight)

    # Построение и вывод матриц
    adj_matrix = graph.adjacency_matrix()
    inc_matrix = graph.incidence_matrix()

    graph.print_matrix(
        adj_matrix,
        "Матрица смежности",
        graph.vertices,
        graph.vertices
    )

    graph.print_matrix(
        inc_matrix,
        "Матрица инцидентности",
        graph.vertices,
        list(graph.edges.keys())
    )

if __name__ == "__main__":
    main()