MINISTERUL EDUCAȚIEI ȘI CERCETĂRII AL REPUBLICII

MOLDOVA
Universitatea Tehnică a Moldovei
Facultatea Calculatoare, Informatică şi Microelectronică
Departamentul Inginerie Software și Automatică

RAPORT
Lucrare de laborator nr. 6
la cursul „Matematica discretă”
Tema: «Разработка программы на C++ для нахождения
остовного графа»

A efectuat : St. gr. TI-228, Covarjic

Ecaterina
A verificat: Asis.univ. Gaidarji
Alina
 Chișinău 2023
Отчет: Разработка программы на C++ для нахождения
остовного графа
Введение: Остовный граф (или остовное дерево) - это подграф связного
неориентированного графа, который содержит все его вершины и является
деревом, то есть не содержит циклов. Остовный граф может быть полезен в
решении различных задач, таких как поиск минимального остовного дерева,
поиск кратчайшего остовного дерева, а также в других приложениях,
связанных с сетями, транспортом и оптимизацией.
Цель: Цель данного проекта - разработать программу на языке C++ для
нахождения остовного графа в неориентированном графе. Программа должна
быть эффективной и обладать понятным интерфейсом, позволяющим
пользователю вводить граф и получать остовный граф в качестве результата.
Описание алгоритма: Для решения данной задачи, можно использовать один
из популярных алгоритмов поиска остовного дерева, таких как алгоритм
Прима или алгоритм Крускала. В данном отчете будет описан алгоритм
Прима, который имеет следующие шаги:
Создание пустого множества, которое будет содержать вершины остовного
графа.
Выбор произвольной вершины и добавление ее в множество остовного
графа.
Пока множество остовного графа не содержит все вершины исходного графа,
выполнять следующие действия:
Найти ребро минимального веса, которое имеет одну вершину в множестве
остовного графа и другую вершину вне множества.
Добавить найденное ребро и вершину, не содержащуюся в множестве, в
множество остовного графа.
Повторять шаг 3 до тех пор, пока множество остовного графа не содержит
все вершины исходного графа.
Описание структур данных: Для реализации алгоритма Прима в программе
на C++, могут быть использованы следующие структуры данных:
Структура данных для представления графа. Граф может быть представлен в
виде списка смежности, где каждая вершина представлена списком ее
соседей и весами ребер между их вершин. Можно использовать структуры
данных, такие как векторы или списки, для хранения списков смежности и
весов ребер.
Структура данных для хранения множества остовного графа. Множество
остовного графа может быть представлено в виде структуры данных, такой
как множество (set) или хеш-таблица (unordered_set) для быстрого поиска и
добавления вершин.
Структура данных для сортировки ребер графа. Для нахождения ребра
минимального веса можно использовать структуры данных, такие как
очередь с приоритетом (priority_queue) или сортированный вектор (sorted
vector), чтобы быстро находить ребра с минимальным весом.
План разработки программы: На основе описанного выше алгоритма и
структур данных можно разработать следующий план для написания
программы на C++:
Создать структуры данных для представления графа, такие как списки
смежности и веса ребер.
Реализовать функцию для считывания графа из входного потока или для
генерации случайного графа для тестирования.
Создать структуру данных для хранения множества остовного графа.
Реализовать алгоритм Прима, основываясь на описанном выше плане. В
цикле выбирать ребра минимального веса и добавлять вершины в множество
остовного графа до тех пор, пока множество не содержит все вершины
исходного графа.
Реализовать функцию для вывода остовного графа в выходной поток или для
вывода результата на экран.
Добавить обработку ошибок, таких как некорректный ввод графа, отсутствие
связности и т. д.
Протестировать программу на различных входных данных, включая тестовые
случаи с разными типами графов (пустой граф, граф с одной вершиной, граф
с несколькими компонентами связности и т. д.).
Оптимизировать программу, если это необходимо, для достижения
наилучшей производительности.
Заключение: В данном отчете был представлен план разработки программы
на C++ для нахождения остовного графа с использованием алгоритма Прима
и соответствующих структур данных. Разработка такой программы может
быть полезна для решения различных задач, связанны
с анализом и обработкой графов, таких как поиск минимального остовного
дерева, оптимизация сетевых связей, роутинг в компьютерных сетях и других
приложений.
Программа, основанная на описанном плане, может быть расширена и
улучшена в дальнейшем, например, добавлением поддержки других
алгоритмов для нахождения остовного графа, таких как алгоритм Крускала
или Борувки, или добавлением дополнительных функций, таких как
визуализация графа и остовного дерева, подсчет суммарного веса остовного
дерева и других.
Важно также учитывать эффективность и оптимизацию алгоритма и структур
данных в зависимости от размера входных данных и требований к
производительности программы. Разработка тестовых случаев и
тестирование программы на различных данных поможет выявить возможные
ошибки и недочеты, и провести необходимую оптимизацию.
В итоге, разработка программы на C++ для нахождения остовного графа
является интересным и актуальным заданием, требующим внимания к
деталям, понимания основных принципов работы алгоритмов на графах, и
применения соответствующих структур данных.

#include <iostream>
#include <vector>

using namespace std;

// Функция для ввода матрицы инцидентности

vector<vector<int>> input_incidence_matrix(int n, int m) {
vector<vector<int>> matrix(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> matrix[i][j];
}
}
return matrix;
}

// Функция для ввода матрицы смежности

vector<vector<int>> input_adjacency_matrix(int n) {
vector<vector<int>> matrix(n, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> matrix[i][j];
}
}
return matrix;
}

// Функция для ввода списка смежности

vector<vector<int>> input_adjacency_list(int n) {
vector<vector<int>> list(n);
int m;
 for (int i = 0; i < n; i++) {
cin >> m;
list[i].resize(m);
for (int j = 0; j < m; j++) {
cin >> list[i][j];
}
}
return list;
}

// Функция для поиска остовного графа в глубину

void dfs(int u, vector<vector<int>>& graph, vector<bool>& visited,
vector<int>& parent) {
visited[u] = true;
for (int v : graph[u]) {
if (!visited[v]) {
parent[v] = u;
dfs(v, graph, visited, parent);
}
}
}

// Функция для поиска остовного графа по заданной вершине

vector<vector<int>> find_spanning_tree(int start, vector<vector<int>>& graph)
{
int n = graph.size();
vector<bool> visited(n, false);
vector<int> parent(n, -1);
dfs(start, graph, visited, parent);

vector<vector<int>> tree(n);
for (int i = 0; i < n; i++) {
if (parent[i] != -1) {
tree[parent[i]].push_back(i);
tree[i].push_back(parent[i]);
}
}
return tree;
}

// Функция для вывода списка смежности на экран

void print_adjacency_list(vector<vector<int>>& list) {
int n = list.size();
for (int i = 0; i < n; i++) {
cout << i << ": ";
for (int j : list[i]) {
cout << j << " ";
}
cout << endl;
}
}

int main() {
int n, m;
cout << "Enter the number of vertices: ";
cin >> n;

cout << "Enter the type of input (1 - incidence matrix, 2 - adjacency

matrix, 3 - adjacency list): ";
int type;
cin >> type;

vector<vector<int>> graph;
switch (type) {
 case 1:
cout << "Enter the number of edges: ";
cin >> m;
graph = input_incidence_matrix(n, m);
break;
case 2:
graph = input_adjacency_matrix(n);
break;
case 3:
graph = input_adjacency_list(n);
break;
default:
cout << "Invalid input type" << endl;
return 0;
}

cout << "Enter the starting vertex: ";

int start;
cin >> start;

vector<vector<int>> spanning_tree = find_spanning_tree(start, graph);

cout << "Spanning tree:" << endl;

print_adjacency_list(spanning_tree);

return 0;
}
/*
Матрица инцидентности:

Enter the number of vertices: 5

Enter the number of edges: 7
Enter the incidence matrix:
0 1 1 0 0 0 0
1 0 0 1 1 0 0
0 0 1 0 1 1 0
0 0 0 0 0 1 1
0 0 0 1 0 0 1
Enter the starting vertex: 0

Матрица смежности:
Enter the number of vertices: 4
Enter the adjacency matrix:
0 1 1 0
1 0 1 1
1 1 0 1
0 1 1 0
Enter the starting vertex: 2

Список смежности:
Enter the number of vertices: 6
Enter the adjacency list:
0 1 3
1 0 2 3
2 1 3 4
3 0 1 2 5
4 2 5
5 3 4
Enter the starting vertex: 4
*/