ОДЕСЬКИЙ НАЦІОНАЛЬНИЙ ПОЛІТЕХНІЧНИЙ УНІВЕРСИТЕТ

ІНСТИТУТ КОМП’ЮТЕРНИХ СИСТЕМ КАФЕДРА «ІНФОРМАЦІЙНИХ

СИСТЕМ»

Практична робота №4
з дисципліни «Теорія алгоритмів»
Тема: Алгоритми на графах

Виконав:
Студент групи АІ-193
Узунов А.Д.
Перевірили:
Арсірій О.О.

Одеса 2020
1.Матрица смежности
1 2 3 4 5 6 7 8

1 0 0 2 4 0 8 0 0

2 0 0 0 6 7 6 0 0

3 2 0 0 0 0 3 0 4
4 4 6 0 0 1 0 0 0

5 0 7 0 1 0 0 4 0

6 8 6 3 0 0 0 5 5

7 0 0 0 0 4 5 0 0

8 0 0 4 0 0 5 0 0
 2. Список смежности
1 3 4 6

2 4 5 6
3 1 6 8

4 1 2 5

5 2 4 7

6 1 2 3,7,8

7 5 6
8 3 6

Алгоритм Прима

Изображение VT ЕT Е V-VT
{1} (1,3)=2 v {2,3,4,5,6,7,
(1,4)=4 8}
(1,6)=8

{1,3} (1,3)=2 (1,4)=4 {2,4,5,6,7,8}

(1,6)=8
(3,6)=3 v
(3,8)=4

{1,3,6} (1,3)=2 (1,4)=4 v {2,4,5,7,8}

(3,6)=3 (1,6)=8
(3,8)=7
(6,2)=6
(6,8)=5
(6,7)=5
 {1,3,6,4} (1,3)=2 (1,6)=8 {2,5,7,8}
(3,6)=3 (3,8)=4
(1,4)=4 (4,5)=1 v
(4,2)=6
(6,2)=6
(6,7)=5
(6,8)=5

{1,3,6,4,5} (1,3)=2 (1,6)=8 {2,7,8}

(3,6)=3 (3,8)=4 v
(1,4)=4 (4,2)=6
(4,5)=1 (5,2)=7
(5,7)=4
(6,7)=5
(6,8)=5
{1,3,6,4,5,8} (1,3)=2 (1,6)=8 {2,7}
(3,6)=3 (4,2)=6
(1,4)=4 (5,2)=7
(4,5)=1 (5,7)=4 v
(3,8)=4 (6,2)=6
(6,7)=5
(6,8)=5
{1,3,6,4,5,8,7 (1,3)=2 (1,6)=8 {7}
} (3,6)=3 (4,2)=6
(1,4)=4 (5,2)=7
(4,5)=1 (6,2)=6 v
(3,8)=4 (6,7)=5
(5,7)=4 (6,8)=5

{1,3,6,4,5,8,7, (1,3)=2 {}
2} (3,6)=3
(1,4)=4
(4,5)=1
(3,8)=4
(5,7)=4
(6,2)=6

Минимальное остовное дерево построено. Его стоимость равна 24

package com.company;
import java.util.*;

public class Main

{
private static int infinite = 9999999;
int[][] LinkCost;
int NNodes;
Main(int[][] mat)
{
int i, j;
NNodes = mat.length;
LinkCost = new int[NNodes][NNodes];
for ( i=0; i < NNodes; i++)
{
for ( j=0; j < NNodes; j++)
{
LinkCost[i][j] = mat[i][j];
if ( LinkCost[i][j] == 0 )
LinkCost[i][j] = infinite;
}
}
for ( i=0; i < NNodes; i++)
{
for ( j=0; j < NNodes; j++)
if ( LinkCost[i][j] < infinite )
System.out.print( " " + LinkCost[i][j] + " " );
else
System.out.print(" * " );
System.out.println();
}
}
public int unReached(boolean[] r)
{
boolean done = true;
for ( int i = 0; i < r.length; i++ )
if ( r[i] == false )
return i;
return -1;
}
public void Prim( )
{
int i, j, k, x, y;
boolean[] Reached = new boolean[NNodes];
int[] predNode = new int[NNodes];
Reached[0] = true;
for ( k = 1; k < NNodes; k++ )
{
Reached[k] = false;
}
predNode[0] = 0;
printReachSet( Reached );
for (k = 1; k < NNodes; k++)
{
x = y = 0;
for ( i = 0; i < NNodes; i++ )
for ( j = 0; j < NNodes; j++ )
{
if ( Reached[i] && !Reached[j] &&
LinkCost[i][j] < LinkCost[x][y] )
{
x = i;
y = j;
}
}
System.out.println("Min cost edge: (" +
+ x + "," +
+ y + ")" +
"cost = " + LinkCost[x][y]);
predNode[y] = x;
 Reached[y] = true;
printReachSet( Reached );
System.out.println();
}
int[] a= predNode;
for ( i = 0; i < NNodes; i++ )
System.out.println( a[i] + " --> " + i );
}
void printReachSet(boolean[] Reached )
{
System.out.print("ReachSet = ");
for (int i = 0; i < Reached.length; i++ )
if ( Reached[i] )
System.out.print( i + " ");
//System.out.println();
}
public static void main(String[] args)
{
int[][] conn =
{{0, 0, 2, 4, 0, 8, 0, 0},
{0, 0, 0, 6, 7, 6, 0, 0},
{2, 0, 0, 0, 0, 3, 0, 4},
{4, 6, 0, 0, 1, 0, 0, 0},
{0, 7, 0, 1, 0, 0, 4, 0},
{8, 6, 3, 0, 0, 0, 5, 5},
{0, 0, 0, 0, 4, 5, 0, 0},
{0, 0, 4, 0, 0, 5, 0, 0}
};

Main G = new Main(conn);

G.Prim();
}
}
Алгоритм Крускалa

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define edge pair<int,int>
class Graph {
private:
vector<pair<int, edge>> G; // graph
vector<pair<int, edge>> T; // mst
int *parent;
int V; // number of vertices/nodes in graph
public:
Graph(int V);
void AddWeightedEdge(int u, int v, int w);
int find_set(int i);
void union_set(int u, int v);
void kruskal();
void print();
};
Graph::Graph(int V) {
parent = new int[V];
//i 0 1 2 3 4 5
//parent[i] 0 1 2 3 4 5
for (int i = 0; i < V; i++)
parent[i] = i;
G.clear();
T.clear();
}
void Graph::AddWeightedEdge(int u, int v, int w) {
G.push_back(make_pair(w, edge(u, v)));
}
int Graph::find_set(int i) {
// If i is the parent of itself
if (i == parent[i])
return i;
else
// Else if i is not the parent of itself
// Then i is not the representative of his set,
// so we recursively call Find on its parent
return find_set(parent[i]);
}
void Graph::union_set(int u, int v) {
parent[u] = parent[v];
}
void Graph::kruskal() {
int i, uRep, vRep;
sort(G.begin(), G.end()); // increasing weight
for (i = 0; i < G.size(); i++) {
uRep = find_set(G[i].second.first);
vRep = find_set(G[i].second.second);
if (uRep != vRep) {
T.push_back(G[i]); // add to tree
union_set(uRep, vRep);
}
}
}
void Graph::print() {
cout << "Edge :" << " Weight" << endl;
for (int i = 0; i < T.size(); i++) {
cout << T[i].second.first << " - " << T[i].second.second << " : "
<< T[i].first;
cout << endl;
}
}
int main() {
Graph g(8);
g.AddWeightedEdge(1, 3, 2);
g.AddWeightedEdge(1, 4, 4);
g.AddWeightedEdge(1, 6, 8);
g.AddWeightedEdge(1, 3, 2);
g.AddWeightedEdge(2, 4, 6);
g.AddWeightedEdge(2, 5, 7);
g.AddWeightedEdge(2, 6, 6);
g.AddWeightedEdge(3, 1, 2);
g.AddWeightedEdge(3, 6, 3);
g.AddWeightedEdge(3, 8, 4);
g.AddWeightedEdge(4, 1, 4);
g.AddWeightedEdge(4, 2, 6);
g.AddWeightedEdge(4, 5, 1);
g.AddWeightedEdge(5, 4, 1);
g.AddWeightedEdge(5, 2, 7);
g.AddWeightedEdge(5, 7, 4);
g.AddWeightedEdge(6, 1, 8);
g.AddWeightedEdge(6, 2, 6);
g.AddWeightedEdge(6, 3, 3);
g.AddWeightedEdge(6, 7, 5);
g.AddWeightedEdge(6, 8, 5);
g.AddWeightedEdge(7, 5, 4);
g.AddWeightedEdge(8, 3, 4);
g.AddWeightedEdge(8, 6, 5);
g.kruskal();
g.print();
return 0;
}

Изображение ЕT Е
{} {(4,5)=1 (1,3)=2
(3,6)=3 (1,4)=4
(3,8)=4 (5,7)=4
(6,7)=4 (6,8)=5
(2,6)=6 (2,4)=6
(2,6)=7 (1,6)=8}
 {(4,5)=1} {(4,5)=1 (1,3)=2
(3,6)=3 (1,4)=4
(3,8)=4 (5,7)=4
(6,7)=4 (6,8)=5
(2,6)=6 (2,4)=6
(2,6)=7 (1,6)=8
{(4,5)=1 (1,3)=2 } {(1,3)=2 (3,6)=3
(1,4)=4 (3,8)=4
(5,7)=4 (6,7)=4
(6,8)=5 (2,6)=6
(2,4)=6 (2,6)=7
(1,6)=8
{(4,5)=1 (1,3)=2 { (3,6)=3 (1,4)=4
(3,6)=3 } (3,8)=4 (5,7)=4
(6,7)=4 (6,8)=5
(2,6)=6 (2,4)=6
(2,6)=7 (1,6)=8
{(4,5)=1 (1,3)=2 { (1,4)=4 (3,8)=4
(3,6)=3 (1,4)=4 } (5,7)=4 (6,7)=4
(6,8)=5 (2,6)=6
(2,4)=6 (2,6)=7
(1,6)=8
{(4,5)=1 (1,3)=2 { (3,8)=4 (5,7)=4
(3,6)=3 (1,4)=4 (6,7)=4 (6,8)=5
(3,8)=4 } (2,6)=6 (2,4)=6
(2,6)=7 (1,6)=8

{(4,5)=1 (1,3)=2 { (5,7)=4 (6,7)=4

(3,6)=3 (1,4)=4 (6,8)=5 (2,6)=6
(3,8)=4 (5,7)=4 } (2,4)=6 (2,6)=7
(1,6)=8

{(4,5)=1 (1,3)=2 { (6,7)=4 (6,8)=5

(3,6)=3 (1,4)=4 (2,6)=6 (2,4)=6
(3,8)=4 (5,7)=4 (2,6)=7 (1,6)=8
(2,4)=6 }

Вывод: во время практической работы были рассмотренны графы, средства

представления графов, определение минимального остовного дерева графа,
алгоритмы Прима (Prim) и Крускала (Kruskal) для построения минимального
остова дерева.