9.2   Базовые операции графа¶

class GraphAdjMat:
    """Класс неориентированного графа на основе матрицы смежности"""

    def __init__(self, vertices: list[int], edges: list[list[int]]):
        """Конструктор"""
        # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
        self.vertices: list[int] = []
        # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
        self.adj_mat: list[list[int]] = []
        # Добавление вершины
        for val in vertices:
            self.add_vertex(val)
        # Добавить ребра
        # Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for e in edges:
            self.add_edge(e[0], e[1])

    def size(self) -> int:
        """Получить число вершин"""
        return len(self.vertices)

    def add_vertex(self, val: int):
        """Добавление вершины"""
        n = self.size()
        # Добавить значение новой вершины в список вершин
        self.vertices.append(val)
        # Добавить строку в матрицу смежности
        new_row = [0] * n
        self.adj_mat.append(new_row)
        # Добавить столбец в матрицу смежности
        for row in self.adj_mat:
            row.append(0)

    def remove_vertex(self, index: int):
        """Удаление вершины"""
        if index >= self.size():
            raise IndexError()
        # Удалить вершину с индексом index из списка вершин
        self.vertices.pop(index)
        # Удалить строку с индексом index из матрицы смежности
        self.adj_mat.pop(index)
        # Удалить столбец с индексом index из матрицы смежности
        for row in self.adj_mat:
            row.pop(index)

    def add_edge(self, i: int, j: int):
        """Добавление ребра"""
        # Параметры i и j соответствуют индексам элементов vertices
        # Обработка выхода индекса за границы и случая равенства
        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
            raise IndexError()
        # В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        self.adj_mat[i][j] = 1
        self.adj_mat[j][i] = 1

    def remove_edge(self, i: int, j: int):
        """Удаление ребра"""
        # Параметры i и j соответствуют индексам элементов vertices
        # Обработка выхода индекса за границы и случая равенства
        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
            raise IndexError()
        self.adj_mat[i][j] = 0
        self.adj_mat[j][i] = 0

    def print(self):
        """Вывести матрицу смежности"""
        print("Список вершин =", self.vertices)
        print("Матрица смежности =")
        print_matrix(self.adj_mat)

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
    vector<int> vertices;       // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    vector<vector<int>> adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

  public:
    /* Конструктор */
    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {
        // Добавление вершины
        for (int val : vertices) {
            addVertex(val);
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for (const vector<int> &edge : edges) {
            addEdge(edge[0], edge[1]);
        }
    }

    /* Получить число вершин */
    int size() const {
        return vertices.size();
    }

    /* Добавление вершины */
    void addVertex(int val) {
        int n = size();
        // Добавить значение новой вершины в список вершин
        vertices.push_back(val);
        // Добавить строку в матрицу смежности
        adjMat.emplace_back(vector<int>(n, 0));
        // Добавить столбец в матрицу смежности
        for (vector<int> &row : adjMat) {
            row.push_back(0);
        }
    }

    /* Удаление вершины */
    void removeVertex(int index) {
        if (index >= size()) {
            throw out_of_range("вершина не существует");
        }
        // Удалить вершину с индексом index из списка вершин
        vertices.erase(vertices.begin() + index);
        // Удалить строку с индексом index из матрицы смежности
        adjMat.erase(adjMat.begin() + index);
        // Удалить столбец с индексом index из матрицы смежности
        for (vector<int> &row : adjMat) {
            row.erase(row.begin() + index);
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    void addEdge(int i, int j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
            throw out_of_range("вершина не существует");
        }
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        adjMat[i][j] = 1;
        adjMat[j][i] = 1;
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    void removeEdge(int i, int j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
            throw out_of_range("вершина не существует");
        }
        adjMat[i][j] = 0;
        adjMat[j][i] = 0;
    }

    /* Вывести матрицу смежности */
    void print() {
        cout << "Список вершин = ";
        printVector(vertices);
        cout << "Матрица смежности =" << endl;
        printVectorMatrix(adjMat);
    }
};

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
    List<Integer> vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    List<List<Integer>> adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

    /* Конструктор */
    public GraphAdjMat(int[] vertices, int[][] edges) {
        this.vertices = new ArrayList<>();
        this.adjMat = new ArrayList<>();
        // Добавление вершины
        for (int val : vertices) {
            addVertex(val);
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for (int[] e : edges) {
            addEdge(e[0], e[1]);
        }
    }

    /* Получить число вершин */
    public int size() {
        return vertices.size();
    }

    /* Добавление вершины */
    public void addVertex(int val) {
        int n = size();
        // Добавить значение новой вершины в список вершин
        vertices.add(val);
        // Добавить строку в матрицу смежности
        List<Integer> newRow = new ArrayList<>(n);
        for (int j = 0; j < n; j++) {
            newRow.add(0);
        }
        adjMat.add(newRow);
        // Добавить столбец в матрицу смежности
        for (List<Integer> row : adjMat) {
            row.add(0);
        }
    }

    /* Удаление вершины */
    public void removeVertex(int index) {
        if (index >= size())
            throw new IndexOutOfBoundsException();
        // Удалить вершину с индексом index из списка вершин
        vertices.remove(index);
        // Удалить строку с индексом index из матрицы смежности
        adjMat.remove(index);
        // Удалить столбец с индексом index из матрицы смежности
        for (List<Integer> row : adjMat) {
            row.remove(index);
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    public void addEdge(int i, int j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw new IndexOutOfBoundsException();
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        adjMat.get(i).set(j, 1);
        adjMat.get(j).set(i, 1);
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    public void removeEdge(int i, int j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw new IndexOutOfBoundsException();
        adjMat.get(i).set(j, 0);
        adjMat.get(j).set(i, 0);
    }

    /* Вывести матрицу смежности */
    public void print() {
        System.out.print("Список вершин = ");
        System.out.println(vertices);
        System.out.println("Матрица смежности =");
        PrintUtil.printMatrix(adjMat);
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
    List<int> vertices;     // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    List<List<int>> adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

    /* Конструктор */
    public GraphAdjMat(int[] vertices, int[][] edges) {
        this.vertices = [];
        this.adjMat = [];
        // Добавление вершины
        foreach (int val in vertices) {
            AddVertex(val);
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        foreach (int[] e in edges) {
            AddEdge(e[0], e[1]);
        }
    }

    /* Получить число вершин */
    int Size() {
        return vertices.Count;
    }

    /* Добавление вершины */
    public void AddVertex(int val) {
        int n = Size();
        // Добавить значение новой вершины в список вершин
        vertices.Add(val);
        // Добавить строку в матрицу смежности
        List<int> newRow = new(n);
        for (int j = 0; j < n; j++) {
            newRow.Add(0);
        }
        adjMat.Add(newRow);
        // Добавить столбец в матрицу смежности
        foreach (List<int> row in adjMat) {
            row.Add(0);
        }
    }

    /* Удаление вершины */
    public void RemoveVertex(int index) {
        if (index >= Size())
            throw new IndexOutOfRangeException();
        // Удалить вершину с индексом index из списка вершин
        vertices.RemoveAt(index);
        // Удалить строку с индексом index из матрицы смежности
        adjMat.RemoveAt(index);
        // Удалить столбец с индексом index из матрицы смежности
        foreach (List<int> row in adjMat) {
            row.RemoveAt(index);
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    public void AddEdge(int i, int j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
            throw new IndexOutOfRangeException();
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        adjMat[i][j] = 1;
        adjMat[j][i] = 1;
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    public void RemoveEdge(int i, int j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
            throw new IndexOutOfRangeException();
        adjMat[i][j] = 0;
        adjMat[j][i] = 0;
    }

    /* Вывести матрицу смежности */
    public void Print() {
        Console.Write("Список вершин = ");
        PrintUtil.PrintList(vertices);
        Console.WriteLine("Матрица смежности =");
        PrintUtil.PrintMatrix(adjMat);
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
type graphAdjMat struct {
    // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    vertices []int
    // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
    adjMat [][]int
}

/* Конструктор */
func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
    // Добавление вершины
    n := len(vertices)
    adjMat := make([][]int, n)
    for i := range adjMat {
        adjMat[i] = make([]int, n)
    }
    // Инициализировать граф
    g := &graphAdjMat{
        vertices: vertices,
        adjMat:   adjMat,
    }
    // Добавить ребра
    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
    for i := range edges {
        g.addEdge(edges[i][0], edges[i][1])
    }
    return g
}

/* Получить число вершин */
func (g *graphAdjMat) size() int {
    return len(g.vertices)
}

/* Добавление вершины */
func (g *graphAdjMat) addVertex(val int) {
    n := g.size()
    // Добавить значение новой вершины в список вершин
    g.vertices = append(g.vertices, val)
    // Добавить строку в матрицу смежности
    newRow := make([]int, n)
    g.adjMat = append(g.adjMat, newRow)
    // Добавить столбец в матрицу смежности
    for i := range g.adjMat {
        g.adjMat[i] = append(g.adjMat[i], 0)
    }
}

/* Удаление вершины */
func (g *graphAdjMat) removeVertex(index int) {
    if index >= g.size() {
        return
    }
    // Удалить вершину с индексом index из списка вершин
    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)
    // Удалить строку с индексом index из матрицы смежности
    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)
    // Удалить столбец с индексом index из матрицы смежности
    for i := range g.adjMat {
        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)
    }
}

/* Добавление ребра */
// Параметры i и j соответствуют индексам элементов vertices
func (g *graphAdjMat) addEdge(i, j int) {
    // Обработка выхода индекса за границы и случая равенства
    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
        fmt.Errorf("%s", "Index Out Of Bounds Exception")
    }
    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
    g.adjMat[i][j] = 1
    g.adjMat[j][i] = 1
}

/* Удаление ребра */
// Параметры i и j соответствуют индексам элементов vertices
func (g *graphAdjMat) removeEdge(i, j int) {
    // Обработка выхода индекса за границы и случая равенства
    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
        fmt.Errorf("%s", "Index Out Of Bounds Exception")
    }
    g.adjMat[i][j] = 0
    g.adjMat[j][i] = 0
}

/* Вывести матрицу смежности */
func (g *graphAdjMat) print() {
    fmt.Printf("\tСписок вершин = %v\n", g.vertices)
    fmt.Printf("\tМатрица смежности = \n")
    for i := range g.adjMat {
        fmt.Printf("\t\t\t%v\n", g.adjMat[i])
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
    private var vertices: [Int] // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    private var adjMat: [[Int]] // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

    /* Конструктор */
    init(vertices: [Int], edges: [[Int]]) {
        self.vertices = []
        adjMat = []
        // Добавление вершины
        for val in vertices {
            addVertex(val: val)
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for e in edges {
            addEdge(i: e[0], j: e[1])
        }
    }

    /* Получить число вершин */
    func size() -> Int {
        vertices.count
    }

    /* Добавление вершины */
    func addVertex(val: Int) {
        let n = size()
        // Добавить значение новой вершины в список вершин
        vertices.append(val)
        // Добавить строку в матрицу смежности
        let newRow = Array(repeating: 0, count: n)
        adjMat.append(newRow)
        // Добавить столбец в матрицу смежности
        for i in adjMat.indices {
            adjMat[i].append(0)
        }
    }

    /* Удаление вершины */
    func removeVertex(index: Int) {
        if index >= size() {
            fatalError("Выход за границы диапазона")
        }
        // Удалить вершину с индексом index из списка вершин
        vertices.remove(at: index)
        // Удалить строку с индексом index из матрицы смежности
        adjMat.remove(at: index)
        // Удалить столбец с индексом index из матрицы смежности
        for i in adjMat.indices {
            adjMat[i].remove(at: index)
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    func addEdge(i: Int, j: Int) {
        // Обработка выхода индекса за границы и случая равенства
        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
            fatalError("Выход за границы диапазона")
        }
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        adjMat[i][j] = 1
        adjMat[j][i] = 1
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    func removeEdge(i: Int, j: Int) {
        // Обработка выхода индекса за границы и случая равенства
        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
            fatalError("Выход за границы диапазона")
        }
        adjMat[i][j] = 0
        adjMat[j][i] = 0
    }

    /* Вывести матрицу смежности */
    func print() {
        Swift.print("Список вершин = ", terminator: "")
        Swift.print(vertices)
        Swift.print("Матрица смежности =")
        PrintUtil.printMatrix(matrix: adjMat)
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
    vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

    /* Конструктор */
    constructor(vertices, edges) {
        this.vertices = [];
        this.adjMat = [];
        // Добавление вершины
        for (const val of vertices) {
            this.addVertex(val);
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for (const e of edges) {
            this.addEdge(e[0], e[1]);
        }
    }

    /* Получить число вершин */
    size() {
        return this.vertices.length;
    }

    /* Добавление вершины */
    addVertex(val) {
        const n = this.size();
        // Добавить значение новой вершины в список вершин
        this.vertices.push(val);
        // Добавить строку в матрицу смежности
        const newRow = [];
        for (let j = 0; j < n; j++) {
            newRow.push(0);
        }
        this.adjMat.push(newRow);
        // Добавить столбец в матрицу смежности
        for (const row of this.adjMat) {
            row.push(0);
        }
    }

    /* Удаление вершины */
    removeVertex(index) {
        if (index >= this.size()) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // Удалить вершину с индексом index из списка вершин
        this.vertices.splice(index, 1);

        // Удалить строку с индексом index из матрицы смежности
        this.adjMat.splice(index, 1);
        // Удалить столбец с индексом index из матрицы смежности
        for (const row of this.adjMat) {
            row.splice(index, 1);
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    addEdge(i, j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)
        this.adjMat[i][j] = 1;
        this.adjMat[j][i] = 1;
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    removeEdge(i, j) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        this.adjMat[i][j] = 0;
        this.adjMat[j][i] = 0;
    }

    /* Вывести матрицу смежности */
    print() {
        console.log('Список вершин = ', this.vertices);
        console.log('Матрица смежности =', this.adjMat);
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
    vertices: number[]; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    adjMat: number[][]; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

    /* Конструктор */
    constructor(vertices: number[], edges: number[][]) {
        this.vertices = [];
        this.adjMat = [];
        // Добавление вершины
        for (const val of vertices) {
            this.addVertex(val);
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for (const e of edges) {
            this.addEdge(e[0], e[1]);
        }
    }

    /* Получить число вершин */
    size(): number {
        return this.vertices.length;
    }

    /* Добавление вершины */
    addVertex(val: number): void {
        const n: number = this.size();
        // Добавить значение новой вершины в список вершин
        this.vertices.push(val);
        // Добавить строку в матрицу смежности
        const newRow: number[] = [];
        for (let j: number = 0; j < n; j++) {
            newRow.push(0);
        }
        this.adjMat.push(newRow);
        // Добавить столбец в матрицу смежности
        for (const row of this.adjMat) {
            row.push(0);
        }
    }

    /* Удаление вершины */
    removeVertex(index: number): void {
        if (index >= this.size()) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // Удалить вершину с индексом index из списка вершин
        this.vertices.splice(index, 1);

        // Удалить строку с индексом index из матрицы смежности
        this.adjMat.splice(index, 1);
        // Удалить столбец с индексом index из матрицы смежности
        for (const row of this.adjMat) {
            row.splice(index, 1);
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    addEdge(i: number, j: number): void {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)
        this.adjMat[i][j] = 1;
        this.adjMat[j][i] = 1;
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    removeEdge(i: number, j: number): void {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        this.adjMat[i][j] = 0;
        this.adjMat[j][i] = 0;
    }

    /* Вывести матрицу смежности */
    print(): void {
        console.log('Список вершин = ', this.vertices);
        console.log('Матрица смежности =', this.adjMat);
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat {
  List<int> vertices = []; // Элемент вершины: элемент представляет «значение вершины», индекс представляет «индекс вершины»
  List<List<int>> adjMat = []; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

  /* Конструктор */
  GraphAdjMat(List<int> vertices, List<List<int>> edges) {
    this.vertices = [];
    this.adjMat = [];
    // Добавление вершины
    for (int val in vertices) {
      addVertex(val);
    }
    // Добавить ребра
    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
    for (List<int> e in edges) {
      addEdge(e[0], e[1]);
    }
  }

  /* Получить число вершин */
  int size() {
    return vertices.length;
  }

  /* Добавление вершины */
  void addVertex(int val) {
    int n = size();
    // Добавить значение новой вершины в список вершин
    vertices.add(val);
    // Добавить строку в матрицу смежности
    List<int> newRow = List.filled(n, 0, growable: true);
    adjMat.add(newRow);
    // Добавить столбец в матрицу смежности
    for (List<int> row in adjMat) {
      row.add(0);
    }
  }

  /* Удаление вершины */
  void removeVertex(int index) {
    if (index >= size()) {
      throw IndexError;
    }
    // Удалить вершину с индексом index из списка вершин
    vertices.removeAt(index);
    // Удалить строку с индексом index из матрицы смежности
    adjMat.removeAt(index);
    // Удалить столбец с индексом index из матрицы смежности
    for (List<int> row in adjMat) {
      row.removeAt(index);
    }
  }

  /* Добавление ребра */
  // Параметры i и j соответствуют индексам элементов vertices
  void addEdge(int i, int j) {
    // Обработка выхода индекса за границы и случая равенства
    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
      throw IndexError;
    }
    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
    adjMat[i][j] = 1;
    adjMat[j][i] = 1;
  }

  /* Удаление ребра */
  // Параметры i и j соответствуют индексам элементов vertices
  void removeEdge(int i, int j) {
    // Обработка выхода индекса за границы и случая равенства
    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
      throw IndexError;
    }
    adjMat[i][j] = 0;
    adjMat[j][i] = 0;
  }

  /* Вывести матрицу смежности */
  void printAdjMat() {
    print("Список вершин = $vertices");
    print("Матрица смежности = ");
    printMatrix(adjMat);
  }
}

/* Тип неориентированного графа на основе матрицы смежности */
pub struct GraphAdjMat {
    // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    pub vertices: Vec<i32>,
    // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
    pub adj_mat: Vec<Vec<i32>>,
}

impl GraphAdjMat {
    /* Конструктор */
    pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {
        let mut graph = GraphAdjMat {
            vertices: vec![],
            adj_mat: vec![],
        };
        // Добавление вершины
        for val in vertices {
            graph.add_vertex(val);
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for edge in edges {
            graph.add_edge(edge[0], edge[1])
        }

        graph
    }

    /* Получить число вершин */
    pub fn size(&self) -> usize {
        self.vertices.len()
    }

    /* Добавление вершины */
    pub fn add_vertex(&mut self, val: i32) {
        let n = self.size();
        // Добавить значение новой вершины в список вершин
        self.vertices.push(val);
        // Добавить строку в матрицу смежности
        self.adj_mat.push(vec![0; n]);
        // Добавить столбец в матрицу смежности
        for row in self.adj_mat.iter_mut() {
            row.push(0);
        }
    }

    /* Удаление вершины */
    pub fn remove_vertex(&mut self, index: usize) {
        if index >= self.size() {
            panic!("index error")
        }
        // Удалить вершину с индексом index из списка вершин
        self.vertices.remove(index);
        // Удалить строку с индексом index из матрицы смежности
        self.adj_mat.remove(index);
        // Удалить столбец с индексом index из матрицы смежности
        for row in self.adj_mat.iter_mut() {
            row.remove(index);
        }
    }

    /* Добавление ребра */
    pub fn add_edge(&mut self, i: usize, j: usize) {
        // Параметры i и j соответствуют индексам элементов vertices
        // Обработка выхода индекса за границы и случая равенства
        if i >= self.size() || j >= self.size() || i == j {
            panic!("index error")
        }
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        self.adj_mat[i][j] = 1;
        self.adj_mat[j][i] = 1;
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    pub fn remove_edge(&mut self, i: usize, j: usize) {
        // Параметры i и j соответствуют индексам элементов vertices
        // Обработка выхода индекса за границы и случая равенства
        if i >= self.size() || j >= self.size() || i == j {
            panic!("index error")
        }
        self.adj_mat[i][j] = 0;
        self.adj_mat[j][i] = 0;
    }

    /* Вывести матрицу смежности */
    pub fn print(&self) {
        println!("Список вершин = {:?}", self.vertices);
        println!("Матрица смежности =");
        println!("[");
        for row in &self.adj_mat {
            println!("  {:?},", row);
        }
        println!("]")
    }
}

/* Структура неориентированного графа на основе матрицы смежности */
typedef struct {
    int vertices[MAX_SIZE];
    int adjMat[MAX_SIZE][MAX_SIZE];
    int size;
} GraphAdjMat;

/* Конструктор */
GraphAdjMat *newGraphAdjMat() {
    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));
    graph->size = 0;
    for (int i = 0; i < MAX_SIZE; i++) {
        for (int j = 0; j < MAX_SIZE; j++) {
            graph->adjMat[i][j] = 0;
        }
    }
    return graph;
}

/* Деструктор */
void delGraphAdjMat(GraphAdjMat *graph) {
    free(graph);
}

/* Добавление вершины */
void addVertex(GraphAdjMat *graph, int val) {
    if (graph->size == MAX_SIZE) {
        fprintf(stderr, "Количество вершин графа уже достигло максимума\n");
        return;
    }
    // Добавить n-ю вершину и обнулить n-ю строку и столбец
    int n = graph->size;
    graph->vertices[n] = val;
    for (int i = 0; i <= n; i++) {
        graph->adjMat[n][i] = graph->adjMat[i][n] = 0;
    }
    graph->size++;
}

/* Удаление вершины */
void removeVertex(GraphAdjMat *graph, int index) {
    if (index < 0 || index >= graph->size) {
        fprintf(stderr, "индекс вершины выходит за границы\n");
        return;
    }
    // Удалить вершину с индексом index из списка вершин
    for (int i = index; i < graph->size - 1; i++) {
        graph->vertices[i] = graph->vertices[i + 1];
    }
    // Удалить строку с индексом index из матрицы смежности
    for (int i = index; i < graph->size - 1; i++) {
        for (int j = 0; j < graph->size; j++) {
            graph->adjMat[i][j] = graph->adjMat[i + 1][j];
        }
    }
    // Удалить столбец с индексом index из матрицы смежности
    for (int i = 0; i < graph->size; i++) {
        for (int j = index; j < graph->size - 1; j++) {
            graph->adjMat[i][j] = graph->adjMat[i][j + 1];
        }
    }
    graph->size--;
}

/* Добавление ребра */
// Параметры i и j соответствуют индексам элементов vertices
void addEdge(GraphAdjMat *graph, int i, int j) {
    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
        fprintf(stderr, "индексы ребра выходят за границы или совпадают\n");
        return;
    }
    graph->adjMat[i][j] = 1;
    graph->adjMat[j][i] = 1;
}

/* Удаление ребра */
// Параметры i и j соответствуют индексам элементов vertices
void removeEdge(GraphAdjMat *graph, int i, int j) {
    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
        fprintf(stderr, "индексы ребра выходят за границы или совпадают\n");
        return;
    }
    graph->adjMat[i][j] = 0;
    graph->adjMat[j][i] = 0;
}

/* Вывести матрицу смежности */
void printGraphAdjMat(GraphAdjMat *graph) {
    printf("Список вершин = ");
    printArray(graph->vertices, graph->size);
    printf("Матрица смежности =\n");
    for (int i = 0; i < graph->size; i++) {
        printArray(graph->adjMat[i], graph->size);
    }
}

/* Класс неориентированного графа на основе матрицы смежности */
class GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {
    val vertices = mutableListOf<Int>() // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    val adjMat = mutableListOf<MutableList<Int>>() // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»

    /* Конструктор */
    init {
        // Добавление вершины
        for (vertex in vertices) {
            addVertex(vertex)
        }
        // Добавить ребра
        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
        for (edge in edges) {
            addEdge(edge[0], edge[1])
        }
    }

    /* Получить число вершин */
    fun size(): Int {
        return vertices.size
    }

    /* Добавление вершины */
    fun addVertex(_val: Int) {
        val n = size()
        // Добавить значение новой вершины в список вершин
        vertices.add(_val)
        // Добавить строку в матрицу смежности
        val newRow = mutableListOf<Int>()
        for (j in 0..<n) {
            newRow.add(0)
        }
        adjMat.add(newRow)
        // Добавить столбец в матрицу смежности
        for (row in adjMat) {
            row.add(0)
        }
    }

    /* Удаление вершины */
    fun removeVertex(index: Int) {
        if (index >= size())
            throw IndexOutOfBoundsException()
        // Удалить вершину с индексом index из списка вершин
        vertices.removeAt(index)
        // Удалить строку с индексом index из матрицы смежности
        adjMat.removeAt(index)
        // Удалить столбец с индексом index из матрицы смежности
        for (row in adjMat) {
            row.removeAt(index)
        }
    }

    /* Добавление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    fun addEdge(i: Int, j: Int) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw IndexOutOfBoundsException()
        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
        adjMat[i][j] = 1
        adjMat[j][i] = 1
    }

    /* Удаление ребра */
    // Параметры i и j соответствуют индексам элементов vertices
    fun removeEdge(i: Int, j: Int) {
        // Обработка выхода индекса за границы и случая равенства
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw IndexOutOfBoundsException()
        adjMat[i][j] = 0
        adjMat[j][i] = 0
    }

    /* Вывести матрицу смежности */
    fun print() {
        print("Список вершин = ")
        println(vertices)
        println("Матрица смежности =")
        printMatrix(adjMat)
    }
}