Raport: Lucrare de Laborator Nr. 4

Ministerul educației a Republicii Moldova
Universitatea tehnică a Moldovei

Facultatea Calculatoare, Informatică și Microelectronică
Filiera francofonă Informatica
Raport
Analiza și proiectarea algoritmilor
Lucrare de laborator nr. 4

Tema : Algoritmi greedy.
Realizat de :
Verificat de :
Chișinau 2020
1. De implementat într-un limbaj de programare algoritmii Prim şi Kruskal.
#include <iostream>
#include <vector>
#include <ctime>
using namespace std;

#define V 10
#define MAX_INT 100
int set[V];
int find(int i)
{
while (set[i] != i)
i = set[i];
return i;
}
void union_set(int i, int j)

{
int a = find(i);
int b = find(j);
set[a] = b;
}
void kruskal(int matrix[][V])

{
int weight = 0;
for (int i = 0; i < V; i++)

set[i] = i;
int edge_count = 0;
while (edge_count < V - 1) {
int min = MAX_INT, a = -1, b = -1;
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (find(i) != find(j) && matrix[i][j] < min && matrix[i][j] != 0) {
min = matrix[i][j];
a = i;
b = j;
}
}
}
union_set(a, b);
edge_count++;
cout << "Connecting edge " << a << " with " << b << endl;
weight += min;
}
cout << endl;
cout << "Total weight = " << weight << endl;
}
bool isValidEdge(int u, int v, vector<bool> inMST)

{
if (u == v)
return false;
if (inMST[u] == false && inMST[v] == false)
return false;
else if (inMST[u] == true && inMST[v] == true)
return false;
return true;
}
void prim(int cost[][V])

{
vector<bool> inMST(V, false);
inMST[0] = true;
int edge_count = 0, mincost = 0;

while (edge_count < V - 1) {
int min = MAX_INT, a = -1, b = -1;

for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (cost[i][j] < min) {
if (isValidEdge(i, j, inMST)) {
min = cost[i][j];
a = i;
b = j;
}
}
}
}
if (a != -1 && b != -1) {
edge_count++;
cout << "Connecting edge " << " " << a << " with " << b << endl;
mincost = mincost + min;
inMST[b] = inMST[a] = true;
}
}
cout << "Minimum cost= " << mincost << endl;
}
int main()
{
int matrix[][V] = {
{0,1,0,0,0,1,0,0,0,0},
{1,0,2,0,1,0,0,0,0,0},
{0,2,0,3,0,0,0,0,0,0},
{0,0,3,0,2,0,0,5,0,0},
{0,1,0,2,0,5,0,4,0,0},
{1,0,0,0,5,0,4,0,0,0},
{0,0,0,0,0,4,0,3,5,0},
{0,0,0,5,4,0,3,0,2,3},
{0,0,0,0,0,0,5,2,0,1},
{0,0,0,0,0,0,0,3,1,0}
};
cout << "Kruskal's algorithm: " << endl;

clock_t start = clock();
kruskal(matrix);
clock_t stop = clock();
cout << "Execution time: " << float(stop)/CLOCKS_PER_SEC << endl;
for(int i = 0; i < V; i++){

for(int j = 0; j < V; j++){
if(matrix[i][j] == 0){
matrix[i][j] = MAX_INT;
}
}
}
cout << "Prim's algorithm: " << endl;

start = clock();
prim(matrix);
stop = clock();
cout << "Execution time: " << float(stop)/CLOCKS_PER_SEC << endl;
return 0;
}
Matrice 50 x 50:
Kruskal's algorithm:
Connecting edge 0 with 4

Total weight = 49
Execution time: 0.011911
Prim's algorithm:
Minimum cost= 49
Execution time: 0.022137
Generarea de matrice random:
int m;
int matrix[V][V];
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
for (int k = 1; k <= 13; k++){
m = rand()% 13;
matrix[i][j]= m;
}
}
}
for(int i=0;i< V;i++){
for(int j = 0;j < V; j++){
cout<< matrix[i][j]<<" ";
}
cout<<"\n";
}
2. De făcut analiza empirică a algoritmilor Kruskal şi Prim.
Pentru valori mari :
Kruskal – verde, Prim – roșu;
Concluzie :
În această lucrare de laborator am studiat algoritmii greedy și mai ales arborii de acoperire minimi
Kruskal și Prim. Algoritmul Kruskal alege muchia de cost minim nealeasă anterior și care nu formează
un ciclu, iar disjoint sets ne permite ușor să executăm algoritmul dat verificând fiecare criteriu cerut. În
algoritmul Prim am inițializat lungimea vârfurile neconectate cu infinit pentru a putea mai ușor afla
compara cu valoarea min în timpul executării algoritmului. Se creează 2 mulțimi, una care conține toate
muchiile grafului iar alta inițial vidă, dar care mai târziu va conține muchiile cu cost minim. La fiecare
pas se alege o muchie de cost minim care se va adăuga în mulțimea u. În ambele cazuri de creează un
arbore, care conectează toate vârfurile grafului. Totuși, după timpul de execuție, putem observa că
algoritmul Kruskal e puțin mai rapid decât Prim, deoarece Prim pierde timp pentru a verifica existența
conexiunii, în timp ce Kruskal deja unește vârfurile în aceleași seturi.

Raport: Lucrare de Laborator Nr. 4

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Raport: Lucrare de Laborator Nr. 4

Uploaded by

Copyright:

Available Formats

Ministerul educației a Republicii Moldova

Universitatea tehnică a Moldovei

Lucrare de laborator nr. 4

using namespace std;

void union_set(int i, int j)

void kruskal(int matrix[][V])

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

bool isValidEdge(int u, int v, vector<bool> inMST)

void prim(int cost[][V])

int edge_count = 0, mincost = 0;

int min = MAX_INT, a = -1, b = -1;

cout << "Kruskal's algorithm: " << endl;

for(int i = 0; i < V; i++){

cout << "Prim's algorithm: " << endl;

Generarea de matrice random:

You might also like