LABORATOR 4

ALGORITMUL LUI BELLMAN-FORD

Exemplu:

Algoritmul Bellman Ford funcționează supraestimând lungimea căii de

la vârful de pornire la toate celelalte vârfuri. Apoi relaxează iterativ
acele estimări găsind noi căi care sunt mai scurte decât căile
supraevaluate anterior. Procedând în mod repetat pentru toate
vârfurile, putem garanta că rezultatul este optimizat.

Fie că avem următorul graf ponerat:

Această problemă a fost explicată la lecția de teorie, prin urmare acum

vom prezenta o metodă simplă de implementare a algoritmului lui
Bellman-Ford:

#include <iostream>
using namespace std;
void BellmanFord(int graph[][3], int V, int E, int src){
// Inițializăm distanța tuturor vârfurilor cu valoarea infinit.
int dis[V];
for (int i = 0; i < V; i++)
dis[i] = INT_MAX;
// Inițializam distanța sursei cu valoarea 0
dis[src] = 0;
// Relaxam toate marginile de (|V|-1) ori.
// O cale simplă cea mai scurtă de la src la orice alt vârf
poate avea cel mult |V|-1 margini.
for (int i = 0; i < V - 1; i++) {
for (int j = 0; j < E; j++) {
if (dis[graph[j][0]] + graph[j][2] < dis[graph[j][1]])

1 din 4 Profesor A.D.

 dis[graph[j][1]] = dis[graph[j][0]] + graph[j][2];
}
}
// Verificam dacă există cicluri de greutate negativă.
// Pasul de mai sus garantează cea mai scurta distanțează dacă
graful nu conține ciclu de greutate negativ.
//Dacă primim o cale mai scurtă, atunci există un ciclu.
for (int i = 0; i < E; i++) {
int x = graph[i][0]; int y = graph[i][1];
int weight = graph[i][2];
if (dis[x] != INT_MAX &&
dis[x] + weight < dis[y])
cout << "Graphul contine un ciclu de greutate
negativ!"<<endl;
}
cout << "Distanta de la virful sursa: " << endl;
for (int i = 0; i < V; i++)
cout << i << "\t\t" << dis[i] << endl;
}
// Programul principal
int main(){
int V = 5; // Numărul de vârfuri în graph
int E = 9; // Numărul muchiilor în graph
// Fiecare muchie are trei valori (u, v, w), unde marginea este
de la vârful u la v. Și greutatea marginii este w.
int graph[][3] = { { 0, 1, 4 },
{ 0, 2, 2 },
{ 1, 2, 3 },
{ 1, 3, 2 },
{ 1, 4, 3 },
{ 2, 1, 1 },
{ 2, 3, 4 },
{ 2, 4, 5 },
{ 4, 3, -5 } };
BellmanFord(graph, V, E, 0); return 0;
}

Soluția obținută în urma execuției codului C++ este:

Distanta de la virful sursa:

0 0
1 3
2 2
3 1
4 6

2 din 4 Profesor A.D.

 SARCINA PENTRU LECȚIA DE LABORATOR

Subgrupa 1
Determinați lungimea minimă de la nodul sursă conform următoarelor date
în dependență de numărul de vârfuri și numărul de muchii ale unui graf
ponderat:

V=5; M=7; V=5; M=7; V=5; M=8; V=5; M=8;

Muchiile: Muchiile: Muchiile: Muchiile:

0 3 3 0 3 1 0 1 -1 0 1 2
0 4 12 0 4 8 0 2 4 0 3 1
1 2 2 1 2 2 1 2 3 1 2 3
2 3 -2 2 3 -4 1 3 2 1 3 4
3 2 3 3 2 3 1 4 2 2 4 1
3 1 5 3 1 4 3 1 1 3 1 -2
4 2 7 4 2 7 3 1 5 3 4 1
4 3 -3 4 1 -3

Subgrupa 2
Determinați lungimea minimă de la nodul sursă conform următoarelor date
în dependență de numărul de vârfuri și numărul de muchii ale unui graf
ponderat:

V=5; M=7; V=5; M=7; V=5; M=7; V=5; M=8;

Muchiile: Muchiile: Muchiile: Muchiile:

0 3 5 0 3 1 0 1 -2 0 1 -5
0 4 6 0 4 -8 0 3 1 0 2 4
1 2 3 1 2 2 1 2 3 1 2 3
2 3 -4 2 3 -4 1 3 4 1 3 6
3 2 6 3 2 3 2 4 2 1 4 3
3 1 -5 3 1 7 3 1 2 3 1 2
4 2 3 4 2 4 3 4 -3 3 1 5
4 1 5 4 3 -4

3 din 4 Profesor A.D.

 SARCINA PENTRU TEMA PENTRU ACASĂ

Analizați exemplele 1-2 de la următoarea pagină web și verificați modul

de implementare al algoritmului Bellman-Ford:

https://www-m9.ma.tum.de/graph-algorithms/spp-bellman-ford/index_en.html

 Scrieți un program în limbajul C++ pentru graful ponderat din

exemplul 1;
 Scrieți un program în limbajul C++ pentru graful ponderat din
exemplul 2;

***SARCINI SUPLIMENTARE***

Utilizați resursele disponibile la următoarea pagină web:

https://graphonline.ru/en/

 Creați un graf corespunzător pentru a aplica algoritmul Floyd-

Warshall pentru a determina drumul minim.
 Efectuați o analiză comparativă a acestor doi algoritmi de
determinare a drumului minim.

4 din 4 Profesor A.D.