16 Вариант.

1. Построить матрицы смежности и списки для взвешенных

неориентированных графов по вариантам заданий.
2. Построить с помощью алгоритма Прима минимальное остовное дерево
(МОД) для графа по вариантам заданий
Показать графически ход построения МОД по алгоритму Прима (Таблица1)
3. Реализовать программно алгоритм Прима. Запустить программу, показать
результат.

Код алгоритма Прима на python:

def prim(matr):
V = len(matr) # number of vertices
num_edge = 0 # number of edge

# create an array to keep selected vertices

selected = []
# fill with start state = false
for i in range(V):
selected.append(False)

# initialize first vertex as true

selected[0] = True

# print for every edge and weight

print("Edge : Weight")
while num_edge < V - 1:

# initialize variable min as infinity

min = float('inf')
x = 0 # row number
y = 0 # column number

# For every vertex in the set

# create for-loop from 0 to number of vertices (V)
for i in range(0, V):
 # if vertex is selected
if selected[i]:
# So create the second for-loop from 0 to number of vertices
(V)
for j in range(0, V):
# if vertex is not selected and there is an edge between
vertex i and vertex j
if not selected[j] and matr[i][j]:
# And if this edge less than min(or infinity)
if min > matr[i][j]:
# We will assign min variable the weight of this
edge
min = matr[i][j]
# And assign x i-vertex and y j-vertex
x = i
y = j

# Show two vertices and edge with weight between them

print(f"{x} - {y} : {matr[x][y]}")
# Change selected vertex at index y to true
selected[y] = True
# And add 1 to the num_edge
num_edge += 1

# def kruskal(matr):

if __name__ == '__main__':
matr_prim = [
[0, 6, 2, 4, 0, 0, 0, 0],
[6, 0, 0, 0, 7, 3, 0, 0],
[2, 0, 0, 8, 8, 5, 0, 4],
[4, 0, 8, 0, 1, 0, 0, 0],
[0, 7, 0, 1, 0, 0, 4, 0],
[0, 3, 5, 0, 0, 0, 6, 0],
[0, 0, 0, 0, 4, 6, 0, 5],
[0, 0, 4, 0, 0, 0, 5, 0]
]

prim(matr_prim)

Результат алгоритма Прима:

Edge : Weight
0-2:2
0-3:4
3-4:1
2-7:4
4-6:4
2-5:5
5-1:3

4. Построить с помощью алгоритма Крускала МОД для графа по вариантам

заданий, Показать графически ход построения МОД по алгоритму Крускала
(Таблица 2)
5. Реализовать программно алгоритм Крускала. Запустить программу,
показать результат.
class Graph:

def __init__(self, vertices):

self.V = vertices # quantity of vertices
self.graph = [] # array to store graphs

# function for add an edge to graph

def addEdge(self, first, second, weight):

self.graph.append([first, second, weight])

# Recursive function to find set of an element i

def find(self, parent, i):
if parent[i] == i:
return i
return self.find(parent, parent[i])

# A function that does union of two sets of x and y

# (uses union by rank)
def union(self, parent, rank, x, y):
xroot = self.find(parent, x)
yroot = self.find(parent, y)

# Attach smaller rank tree under root of

# high rank tree (Union by Rank)
if rank[xroot] < rank[yroot]:
parent[xroot] = yroot
elif rank[xroot] > rank[yroot]:
parent[yroot] = xroot

# If ranks are same, then make one as root

# and increment its rank by one
else:
parent[yroot] = xroot
rank[xroot] += 1

# The main function to construct MST using Kruskal's

# algorithm
def KruskalMST(self):
 result = [] # This will store the resultant MST

# An index variable, used for sorted edges

i = 0

# An index variable, used for result[]

e = 0

# Step 1: Sort all the edges in

# non-decreasing order of their
# weight. If we are not allowed to change the
# given graph, we can create a copy of graph
self.graph = sorted(self.graph,
key=lambda item: item[2])

parent = []
rank = []

# Create V subsets with single elements

for node in range(self.V):
parent.append(node)
rank.append(0)

# Number of edges to be taken is equal to V-1

while e < self.V - 1:

# Step 2: Pick the smallest edge and increment

# the index for next iteration
u, v, w = self.graph[i]
i = i + 1
x = self.find(parent, u)
y = self.find(parent, v)

# If including this edge does't

# cause cycle, include it in result
# and increment the indexof result
# for next edge
if x != y:
e = e + 1
result.append([u, v, w])
self.union(parent, rank, x, y)
# Else discard the edge

print("Edge: Weight:")
for u, v, weight in result:
print(f"{u} -- {v} == {weight}")

if __name__ == '__main__':
g = Graph(8)
g.addEdge(0, 1, 6)
g.addEdge(0, 2, 2)
g.addEdge(0, 3, 4)
g.addEdge(1, 4, 7)
g.addEdge(1, 5, 3)
g.addEdge(2, 7, 4)
g.addEdge(2, 5, 5)
g.addEdge(2, 3, 8)
g.addEdge(3, 4, 1)
g.addEdge(4, 6, 4)
g.addEdge(5, 6, 6)
g.addEdge(6, 7, 5)
 # Function call
g.KruskalMST()

Результат:

Edge: Weight:
3 -- 4 == 1
0 -- 2 == 2
1 -- 5 == 3
0 -- 3 == 4
2 -- 7 == 4
4 -- 6 == 4
2 -- 5 == 5

6. Выводы

В данной лабораторной работе мы ознакомились с двумя новыми

алгоритмами (Прима и Крускала) для построение минимального остовного
дерева (МОД). Трудности возникали, но только с работой с алгоритмом
Крускала. Алгоритм Прима оказался для меня легче в понимании и
реализации.