ATP - Sem.

11
1. Parcurgere grafuri
a) Metoda de parcurgere in latime (BF Breadth First) - presupune parcurgerea n
lime a grafului, n sensul c, vrfurile grafului snt prelucrate n ordinea
cresctoare a distanelor in raport cu vrful iniial (se foloseste o structura de
tip coada).
Scrieti programul C care sa realizeze parcurgerea de tip BF a unui graf
neorientat. Pentru cazul grafului de mai jos, avand:
- ca varf de plecare varful 1,
- 7 varfuri,
- 1o muchii,
rezultatul este: 1,2,3,4,7,5,6

Exemplu rulare:

Indicatii
1. Biblioteci;
2. Declarari variabile de tip intreg: a[20][20], coada[20], viz[20],
i,n,el,pl,j,m,x,y,p,u;
3. In functia main:
-

Se citesc de la tastatura n (nr de noduri) si m ( numarul de

muchii);
- Se creeaza matricea de adiacenta care marcheaza existenta
muchiilor din graf:
{
-se citesc de la tastatura x (vf de unde pleaca muchia) si y (vf
unde ajunge muchia)
- se creeaza matricea de adiacenta:
}
se mentioneaza ca nodurile nu sunt vizitate prin initializarea lui
viz[i] cu zero
- Se citeste pl de la tastatura - nodul din care se pleaca pentru
parcurgerea BF
- Se realizeaza parcurgereagrafului:
- se afiseaza valorile din coada ( nodurile in ordinea vizitarii)
b) Metoda de parcurgere in adancime (DF Depth First) exploreaza straturile din
ce in ce mai adanci, ori de cate ori este posibil (foloseste o structura de tip stiva).

Algoritm
-

stiva S este iniializat cu vrful v0;

ct timp S ,
o Se extrage i viziteaz un vrf i din stiv
o Varianta I de gestiune a stivei:
se introduc n stiv vecinii lui i care nu au fost deja
introdui (acele vrfuri k cu proprietatea c c[k]=0 i
a[i][k]=1). Vrfurile i ce au fost introduse n stiv snt
marcate prin v[i]=1.
o Varianta II de gestiune a stivei:
se introduce in stiva unul dintre vecinii varfului curent
inca nevizitat. Vizitarea unui varf revine la
introducerea lui in S. Daca varful curent nu are vecini
inca nevizitati, atunci el este eliminat din stiva si este
efectuat un nou acces de preluare a noului varf al
stivei ca varf curent.

Scrieti programul C care sa realizeze parcurgerea de tip DF a unui graf

neorientat (varianta II de gestiune a stivei). Pentru cazul grafului de mai
jos, avand:
- ca varf de plecare varful 1,
- 7 varfuri,
- 11 muchii,
rezultatul este: 1,2,4,3,6,7,5 (varianta II)

Exemplu de rulare

Indicatii:
1.Biblioteci
2.Declarari variabile de tip intreg: a[20][20], viz[20], i,n,pl,j,m,x,y;
3. Functia de parcurgere DF:
void parc_adancime(int pl) // pl nodul asupra caruia se aplica
{ int j;
printf("nod vizitat=%d\n",pl);
viz[pl]=1; //marcheaza nodul ca fiind vizitat
for(j=1;j<=n;j++)
if((a[pl][j]==1)&&(viz[j]==0)) //pt fiecare vecin nevizitat
parc_adancime(j); //se autoapeleaza fct de parcurgere
}
4. In functia main:
- Se citesc de la tastatura n (nr de noduri) si m ( nr de muchii)
- Se creeaza matricea de adiacenta:
for(i=1;i<=m;i++)
{
-secitesc de la tastatura x si y;
- se marcehaza muchiile in matrice:
a[x][y]=1;
a[y][x]=1;
}
for(i=1;i<=n;i++)
viz[i]=0;//se mentioneaza ca nodurile nu sunt vizitate
-

Se citeste de la tastatura pl nodul de plecare

Se apeleaza functia de parcurgere DF ( parc_adancime(pl); )

2. Matrice de existenta a drumurilor, alg . Roy- Warshall

Scrieti un subprogram care calculeaza matricea existentei drumurilor intr-un graf neponderat (alg.
Roy -Warshall). Datele sunt memorate in fisierul "g1.txt", pe prima linie 6 (nr. de varfuri) si 8 ( nr. de linii),
apoi urmand muchiile.
Continutul fisierului g1.txt este:
68
12
13
24
26
34
35
45
56
Exemplu de rulare:

Indicatii:
1. includere biblioteci
2. scriere functia: int citire_graf_n (char *numef, int *nrv, int *nrm, int ***g) pt graf neponderat g1.txt
int citire_graf_n (char *numef, int *nrv, int *nrm, int ***g)
{ FILE *f;
int i, er;
f=fopen (numef, "r");
if (!f) er=1;
else {
er=0;
fscanf(f,"%d %d", nrv, nrm);
printf ("%d %d\n\n", *nrv, *nrm) ; //eu
*g=(int**) malloc (*nrm*sizeof(int*));
for (i=0;i<*nrm;i++)
(*g)[i]=(int*) malloc(3*sizeof(int));
for (i=0;i<*nrm;i++)
{ fscanf (f,"%d %d", &(*g)[i][0],&(*g)[i][1]);
printf ("%d %d\n", (*g)[i][0], (*g)[i][1]); //eu
}
fclose (f);
}
return er;
}

3. se scrie functia de conversie: int **conversie(int nrv, int nrm, int **tabel, int *dim).
int **conversie(int nrv, int nrm, int **tabel, int *dim)
{int i,j;
int **mat;
*dim=nrv;
mat=(int**) malloc (*dim*sizeof(int*));
for (i=0;i<*dim;i++)

mat[i]=(int*) malloc(*dim*sizeof(int)); //sau *(mat+i)

for (i=0;i<*dim;i++)
for (j=0;j<*dim;j++)
mat[i][j]=0;
for (i=0;i<nrm;i++)
{ mat[tabel[i][0]-1][tabel[i][1]-1]=1;
mat[tabel[i][1]-1][tabel[i][0]-1]=1;
}
return mat;
}

4. se scrie functia de afisare a matricii ( void afisareMatrice (int **mat, int m, int n) )
5. se scrie functia Roy_Warshall ( I: matrice adiacenta, nr. varfuri; E: matricea existentei drumurilor,
dimensiune):
int **Roy_Warshall(int **a, int n, int *dim)
{ - declaratii: int i,j,k, **m;
- *dim ia valoarea nr. de varfuri ( *dim=n;)
- se aloca memorie pentru matrice
m=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
m[i]=(int*)malloc(n*sizeof(int));
- se copiaza matricea de adiacenta a in matricea de existenta a drumurilor m
for(i=0;i<n;i++)
for(j=0;j<n;j++)
m[i][j]=a[i][j];
- se verifica daca graful este conex (toate elementele lui m sunt 1 )
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if (m[i][j]==1)
for(k=0;k<n;k++)
if (m[j][k]==1)
m[i][k]=m[k][i]=1;
- return m;
}
7. functia main
{ - declarari: FILE f; char numefis[30]; int n,m, **tabel,**a, dim,er, **m_dr, l;
- citire nume fisier de la tastatura (gets(numefis); )
- se verifica daca s-a putut deschide fisierul:
er=citire_graf_n(numefis, &n, &m, &tabel);
if (er==0) printf("\nFisierul cu graful s-a deschis!\n");
else printf("\nNu s-a putut deshide fisierul");

- se apeleaza functia de conversie pentru matricea a (a=conversie(n,m,tabel,&dim);)

- se afiseaza matricea a (afisareMatrice(a,n,m-2);
- se apeleaza functia Roy_Warshall():
m_dr=Roy_Warshall(a,dim,&l);
- se afiseaza matricea m_dr (afisareMatrice(m_dr,n,dim));
}

TEMA
1. Scrieti programul C care sa rezolve problema parcurgerii de tip DF
generalizata (DFG) ( aceasta consta in vizitarea tuturor varfurilor grafului
analizat (considerat neorientat sau directionat), indiferent daca acesta
este conex sau nu).
2. Identificati gradul unui nod.
3. Identificati nodurile izolate dintr-un grad neorientat, ponderat.