Lucrare de laborator Nr.

5
Tema: Algoritmi de determinare a drumului minim.
1. Scopul lucrării:
1. Studierea algoritmilor de determinare a drumurilor minime și maxime
într- un graf;
2. Elaborarea programelor de determinare a drumului minim și maxim într-
un graf ponderat.
2. Sarcina:
1. Elaboraţi procedura introducerii unui graf ponderat.
2. Elaboraţi procedurile determinării drumului minim utilizând
algoritmul Bellman-Kalaba.
3. Realizaţi un program cu următoarele funcţii:
 Introducerea grafului ponderat cu posibilităţi de analiză sintactică
şi semantică şi de corectare a informaţiei;
 Determinarea drumului minim utilizând algoritmul Bellman-Kalaba
 Extragerea informaţiei la display (valoarea drumului minim şi
succesiunea vârfurilor care formează acest drum);

3. Întrebări de control:
1. Ce se numeşte graf ponderat?
2. Definiţi noţiunea de distanţă.
3. Care sunt momentele principale în algoritmul Bellman-Kalaba?
4. Prin ce se deosebeşte algoritmul Ford de algoritmul Bellman-Kalaba?
5. Cum se va stabili succesiunea vârfurilor care formează drumul minim?

#include<stdio.h>
#include<stdlib.h>

#define MAX 100

#define infinity 9999
#define NIL -1
#define TRUE 1
#define FALSE 0

int varfuri, arce;

int **matrice;

int *predecessor;
int *pathLength;
int *isPresent_in_queue;

int front,rear;
int *queue;
void initialize_queue( );
void insert_queue(int u);
int delete_queue();
int isEmpty_queue();
void introducerea_datelor();
void findPath(int s, int v);
int BellmanFord(int s);

int main()
{
int flag,s,v;
printf ("Introduceti numarul de varfuri:\n");
scanf ("%d", &varfuri);
printf ("Introduceti numarul de arce:\n");
scanf ("%d", &arce);

matrice = calloc(varfuri, sizeof(int*));

for (int i = 0; i <varfuri; i++)
matrice[i] = calloc (varfuri, sizeof(int));
predecessor = calloc (varfuri, sizeof(int));
pathLength = calloc (varfuri, sizeof(int));
isPresent_in_queue = calloc (varfuri, sizeof(int));
queue = calloc (varfuri, sizeof(int));

introducerea_datelor();

printf("\nEnter source vertex : ");

scanf("%d",&s);

flag = BellmanFord(s-1);

if(flag == -1)
{
printf("\nError : negative cycle in Graph\n");
exit(1);
}

while(1)
{
printf("\nEnter destination vertex(-1 to quit): ");
scanf("%d",&v);
 if(v == -1)
break;
if(v <= 0 || v > varfuri )
printf("\nThis vertex does not exist\n");
else if(v == s)
printf("\nSource and destination vertices are same\n");
else if( pathLength[v-1] == infinity )
printf("\nThere is no path from source to destination vertex\n");
else
findPath(s-1,v-1);
}
for (int i=0; i<varfuri; i++)
free(matrice[i]);
free(matrice);
free(predecessor);
free(pathLength);
free(isPresent_in_queue);
free(queue);
return 0;
}/*End of main()*/

void findPath(int s, int v )

{
int i,u;
int path[MAX]; /*stores the shortest path*/
int shortdist = 0; /*length of shortest path*/
int count = 0; /*number of vertices in the shortest path*/

/*Store the full path in the array path*/

while( v != s )
{
count++;
path[count] = v;
u = predecessor[v];
shortdist += matrice[u][v];
v = u;
}
count++;
path[count]=s;

printf("\nShortest Path is : ");

for(i=count; i>=1; i--)
printf("%d ",path[i]+1);
printf("\n Shortest distance is : %d\n", shortdist);
}/*End of findPath()*/
int BellmanFord(int s)
{
int k = 0,i,current;

for(i=0;i<varfuri;i++)
{
predecessor[i] = NIL;
pathLength[i] = infinity;
isPresent_in_queue[i] = FALSE;
}

initialize_queue( );
pathLength[s] = 0; /*Make pathLength of source vertex 0*/
insert_queue(s); /*Insert the source vertex in the queue*/
isPresent_in_queue[s] = TRUE;
while( !isEmpty_queue( ) )
{
current = delete_queue( );
isPresent_in_queue[current] = FALSE;
if(s == current)
k++;
if(k > varfuri )
return -1;/*Negative cycle reachable from source vertex*/
for(i=0;i<varfuri;i++)
{
if ( matrice[current][i] != 0 )
if( pathLength[i] > pathLength[current] + matrice[current][i] )
{
pathLength[i] = pathLength[current] + matrice[current][i];
predecessor[i] = current;
if( !isPresent_in_queue[i] )
{
insert_queue(i);
isPresent_in_queue[i]=TRUE;
}
}
}
}
return 1;
}/*End of BellmanFord()*/

void initialize_queue( )
{
int i;
rear = -1;front = -1;
}/*End of initailize_queue()*/
int isEmpty_queue()
{
if(front == -1 || front>rear )
return 1;
else
return 0;
}/*End of isEmpty_queue()*/

void insert_queue(int added_item)

{
if (rear == varfuri-1)
{
printf("\nQueue Overflow\n");
exit(1);
}
else
{
if (front == -1) /*If queue is initially empty */
front = 0;
rear = rear+1;
queue[rear] = added_item ;
}
}/*End of insert_queue()*/

int delete_queue()
{
int d;
if (front == -1 || front > rear)
{
printf("\nQueue Underflow\n");
exit(1);
}
else
{
d = queue[front];
front=front+1;
}
return d;
}/*End of delete_queue() */

void introducerea_datelor ()
{

int n, m, p;

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

{
iesire:
 printf ("\nIntroduceti arcul %d: ", i+1);
scanf ("%d %d", &n, &m);
printf ("/ponderea:");
scanf ("%d", &p);
if (n>varfuri || m>varfuri)
{
printf ("Datelor introduse sunt incorecte\n");
goto iesire;
}
matrice[n-1][m-1] = p;
}
}