Лабораторна робота №5

Тема роботи: Реалізація алгоритмів Дейкстри, Флойда та Форда

Фалкерсона.
Мета роботи: Дослідити задачу знаходження найкоротших шляхів:
а) від джерела до всіх інших вершин заданого графа (алгоритм
Дейкстри);
б) між усіма парами вершин заданого графа (алгоритм Флойда);
в) пропускна спроможність орієнтованого графа (Форда Фалкерсона)
Обладнання: Комп’ютер, середовище розробки C#.

Хід роботи
Завдання:
1. Неорієнтований граф G(V,E), граф взяти з лабораторної роботи №4,
нанести на ребра напрям. ТА
Н. Контр.
Розроб.
Змн.
Затверд.
Перевір.
Арк. Гречушкiн
Ляшок В.Г.I.M. .
№ докум. Підпис Дата КНУ ЛР.151.21.03.02
Літ. АКНТ
1 КН-22-1
Арк. Аркушів
2. Для заданого графа знайти найкоротший шлях від першої вершини
(джерела) до всіх інших вершин заданого графа, використовуючи
алгоритм Дейкстри.
3. Для заданого графа оцінити пропускну здатність графа за допомогою
алгоритму Форда Фалкерсона.
4. Для заданих алгоритмів провести ручний розрахунок та виконати
програмну реалізацію згідно варіанту.

Граф:
 Виконання:
Алгоритм Дейкстри:

Код программи:
using System;
using System.Collections.Generic;

class DijkstraAlgorithm
{
static void Main()
{
int[,] graph = {
{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 14, 10, 0, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};

Dijkstra(graph, 0);
}

static void Dijkstra(int[,] graph, int source)

{
int verticesCount = graph.GetLength(0);
int[] distance = new int[verticesCount];
bool[] shortestPathTreeSet = new bool[verticesCount];

for (int i = 0; i < verticesCount; ++i)

{
distance[i] = int.MaxValue;
shortestPathTreeSet[i] = false;
}

distance[source] = 0;

for (int count = 0; count < verticesCount - 1; ++count)

{
int u = MinDistance(distance, shortestPathTreeSet, verticesCount);
shortestPathTreeSet[u] = true;

Арк.
Лабораторна робота 1
 for (int v = 0; v < verticesCount; ++v)
{
if (!shortestPathTreeSet[v] &&
graph[u, v] != 0 &&
distance[u] != int.MaxValue &&
distance[u] + graph[u, v] < distance[v])
{
distance[v] = distance[u] + graph[u, v];
}
}
}

PrintSolution(distance, verticesCount);
}

static int MinDistance(int[] distance, bool[] shortestPathTreeSet, int verticesCount)

{
int min = int.MaxValue;
int minIndex = 0;

for (int v = 0; v < verticesCount; ++v)

{
if (shortestPathTreeSet[v] == false && distance[v] <= min)
{
min = distance[v];
minIndex = v;
}
}

return minIndex;
}

static void PrintSolution(int[] distance, int verticesCount)

{
Console.WriteLine("Vertex \t\t Distance from Source Vertex");
for (int i = 0; i < verticesCount; ++i)
{
Console.WriteLine($"{i}\t\t {distance[i]}");
}
}
}

Демонстрація роботи программи:

Рис.1

Ручна реалізація:

Арк.
Лабораторна робота 1
Рис 2

Арк.
Лабораторна робота 1
 Рис 3
алгоритм Форда Фалкерсона:
Код программи:
using System;
using System.Collections.Generic;

class FordFulkerson
{
static int V = 9; // Кількість вершин у графі

static int FordFulkersonAlgorithm(int[,] graph, int source, int sink)

{
int[,] residualGraph = new int[V, V];
Array.Copy(graph, residualGraph, graph.Length);

int[] parent = new int[V]; // Зберігає шлях у збільшувальному шляху

int maxFlow = 0; // Ініціалізуємо максимальний потік

while (BFS(residualGraph, source, sink, parent))

{
int pathFlow = int.MaxValue;

// Знаходження максимального потоку в збільшувальному шляху

for (int v = sink; v != source; v = parent[v])
{
int u = parent[v];
pathFlow = Math.Min(pathFlow, residualGraph[u, v]);
}

Арк.
Лабораторна робота 1
 // Оновлення залишкового графу
for (int v = sink; v != source; v = parent[v])
{
int u = parent[v];
residualGraph[u, v] -= pathFlow;
residualGraph[v, u] += pathFlow;
}

// Додавання потоку з поточного шляху до загального потоку

maxFlow += pathFlow;
}

return maxFlow;
}

static bool BFS(int[,] rGraph, int source, int sink, int[] parent)
{
bool[] visited = new bool[V];
Queue<int> queue = new Queue<int>();

visited[source] = true;
queue.Enqueue(source);
parent[source] = -1;

while (queue.Count != 0)
{
int u = queue.Dequeue();

for (int v = 0; v < V; v++)

{
if (visited[v] == false && rGraph[u, v] > 0)
{
queue.Enqueue(v);
parent[v] = u;
visited[v] = true;
}
}
}

return visited[sink];
}

public static void Main()

{
int[,] graph = {
{0, 10, 10, 0, 0, 0, 0, 0, 0},
{0, 0, 2, 4, 8, 0, 0, 0, 0},
{0, 0, 0, 0, 9, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 10, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 10, 6, 0},
{0, 0, 0, 0, 0, 0, 0, 10, 0},
{0, 0, 0, 0, 0, 2, 0, 0, 10},
{0, 0, 0, 0, 0, 0, 0, 0, 10},
{0, 0, 0, 0, 0, 0, 0, 0, 0}
};

int source = 0;
int sink = 8;

int maxFlow = FordFulkersonAlgorithm(graph, source, sink);

Console.WriteLine($"Максимальний потiк: {maxFlow}");

}
}
Демонстрація роботи программи:

Арк.
Лабораторна робота 1
 Рис.4

Ручна реалізація:

Висновок:
Виконуючи данну лабораторну роботу я дослідв задачу знаходження
найкоротших шляхів від джерела до всіх інших вершин заданого графа
за допомогою алгоритму Дейкстри , та пропускну спроможність
орієнтованого графа за допомогою алгоритма Форда Фалкерсона.

Арк.
Лабораторна робота 1