Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

RAPORT
Lucrare de laborator nr.1
la Matematica Discreta
Tema: Păstrarea grafurilor în memoria calculatorului.
Algoritmul de cautare in adincime.Algoritmul de cautare in latime

A elaborat:
st. gr. CR-182 Mardari I.

A verificat:
lector superior Andrievschi-Bagrin V.

• Scopul și obiectivele lucrării

 • Studierea metodelor de definire a unui graf:
• Matricea de incidență
• Matricea de adiacență
• Liste

• Elaborarea unor proceduri de introducere, extragere și transformare a diferitelor

forme de reprezentare internă a grafurilor cu scoaterea rezultatelor la display și
imprimantă.

• Studierea metodelor de redactare/modificare a grafului.

• Sarcina lucrării
• Elaborarea a unui program care să permită introducerea unui graf arbitrar.

• Afișarea de la ecran a trei forme de stocare a grafului:

• Matrice de incidență

• Matrice de adiacență

• Listă de adiacență

• Redacatare grafului:

• Ștergerea unui arc

• Adăugarea unui arc

• Ștergerea unui vârf

• Adăugarea unui vârf

 • Considerații teoretice

Se numește graf, G=(X,F), ansamblu format dintr-o mulțime finită X si o aplicație F a lui X
în X.
Elementele mulțimii X se numesc vârfurile grafului. Perechea de vârfuri (x,y) se numește arc, vârful
x se numeste originea sau extremitatea inițială a arcului (x,y) iar vârful y se numește extremitatea
finală sau terminală.

Dacă un vârf nu este extremitatea nici unui arc el se numeste vârf izolat, iar dacă este
extremitatea a mai mult de două arce- nod. Un arc (x,y) pentru care extremitatea inițială coincide cu
cea finală se numește buclă.

Exista 3 metode de baza de definire a unui graf:

• Matricea de incidență;

• Matricea de adiacentă;

• Lista de adiacență.

Matricea de incidenţă
Este o matrice de tipul mxn, în care m este numărul de muchii sau arce (pentru un graf orientat), iar
n este numărul vârfurilor. La intersecţia liniei i cu coloana j se vor considera valori de 0, 1 sau -1 în
conformitate cu următoarea regulă:
• 1 - dacă muchia/arcul i "intră" în vârful j în cazul unui graf orientat;

• 0 - dacă muchia (arcul) i şi vârful j nu sunt incidente;

• -1 - dacă arcul i "iese" din vârful j.

Matricea de adiacenţă
Este o matrice pătrată nxn, aici n este numărul de vârfuri. Fiecare element poate fi 0, dacă vârfurile
respective nu sunt adiacente, sau 1, în caz contrar.

Lista de adiacenţă
Lista de adiacenţă este o listă cu n linii (după numărul de vârfuri n), în linia cu numărul i vor fi
scrise numerele vârfurilor adiacente cu vârful i.
 x1 x2 x3 x4 x5
MI
 u1 0 1 0 0 -1

u2 1 0 0 0 -1
u3 -1 1 0 0 0

u4 0 0 1 0 -1
u5 0 0 -1 1 0

u6 0 1 -1 0 0
u7 0 -1 0 1 0
MA x1 x2 x3 x4 x5
x1 0 1 0 0 0
x2 0 0 0 1 0
x3 0 1 0 1 0
x4 0 0 0 0 0
x5 1 1 1 0 0
Xi F(xi)
x1 2,0

x2 4,0
x3 2,4,0

x4 0
x5 1,2,3,0

Fig.1 Lista Fig.2 Matricea de adiacenta

Fig.3 Matricea de incidenta

• Mersul lucrării
Sarcina nr.1

Am încercat să efectuez introducerea unui graf arbitrar sub trei forme:

• Matrice de incidență
• Matrice de adiacență
• Listă de adiacență

• Introducerea unei matrici sub forma unei matrice de incidență:

Pentru aceasta am creat funcția read_matinc.
Introducem nunărul de vârfuri n, și numărul de muchii b:
putstr(" Nr. de varfuri:");
scanf("%d", &n);
putstr("Nr.de muchii : ");
scanf("%d", &b);

apoi introducem elementele matricei, k, sub formă de -1 (plecarea din vârf), 1(sosirea în
vârf), și 0, în cazul cînd nu există drum.
for(i=1; i<=b; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor (WHITE);
for(j=1; j<=n; j++)
{
t=NULL;
scanf("%d", &k);
if(k==1)
node=j;
else if (k==-1)
t=find_node(*begin,j);
else if(k!=0)
{
node=j;
t=find_node(*begin,j);
}
}

Elementele se vor citi sub forma unei matrici cu dimensiunea nxb, unde n - numărul de
vârfuri, b - numărul de arce. Pentru convertirea ulterioară a grafului în celelatle forme,
efectuăm toate sarcinile alocînd memoria dinamic.

• Introducerea unei matrici sub forma unei matrice de adiacență:

Pentru citire matricei sub această formă, utilizăm funcția read_matad, e necesar să
introducem nr de vîrfuri n:
puts("Nr. de varfuri: ");
scanf("%d", &n);
formând matricea patratică cu dimensiunea nxn, completăm matricea cu zerouri și unități, dacă
există drum din xi în xj, atunci se completeză cu 1, în caz contrar cu 0.
for(j=1; j<=n; j++)
{
scanf("%d", &k);
if(k!=0)
 list_add(&(t->bow),j,k);
}

• Introducerea unei matrici sub forma unei liste de adiacență:

Lista de adiacenţă este o listă cu n linii, în linii vor fi scrise numerele vârfurilor adiacente cu
vârful i.
Inițial introducem nr de vîrfuri n
puts("Nr. de varfuri: ");
scanf("%d", &n);
și fiecărui vârf îi atribuim vârfurile spre care ele pleacă. Completând linia numărul 1, pentru
vârful inițial, trecem la vârful numărul 2, marcând finalul liniei prin 0.
for (i=1; i<=n; i++)
{
SetColor(MAGENTA);
printf("%3d: ", i);
SetColor(WHITE);
k=0;
t=graph_add(begin,i);
scanf("%d", &k);
while(k)
{
list_add(&(t->bow),k,1);
scanf("%d", &k);
}
}
Pentru a lua în consideraţie lungimea variabilă a liniilor se utilizează variabile dinamice şi pointeri.

Sarcina nr.2

Afișarea de la ecran a trei forme de stocare a grafului:

• Matrice de incidență
• Matrice de adiacență
• Listă de adiacență

• Afișarea ca matrice de incidență:

Pentru aceasta am creat o funcție show_matinc. În cazul dacă matricea nu a fost inițial citită, se
va afișa la ecran alerta “Graful este vid”. Inițializez o matrice 2d de tip int **mat, și o egalez cu
funcția ft_newmat, astfel alocîndu-i memorie dinamic:
mat=(int**)malloc(sizeof(int*) *m);
if (!mat) return (NULL);
for (i=0; i<m; i++){ mat[i]=(int*)malloc(sizeof(int) *n);

Apoi cu ajutorul funcției ft_initmat, în care sunt păstrate valorile matricei:

for(i=0; i<m; i++)
for(j=0; j<n; j++)
mat[i][j]=value;
În cazul în care valoarea vârfului inițial era egală cu valoarea vârfului final (buclă), se afișează
 valoarea- 2. Iar în restul cazurilor vârfului inițial i se atribuia -1, iar celui final 1. După care se
afișează matricea, și apoi îi dealocăm memorie prin funcția ft_freemat.
while(begin)
{
lst=begin->bow;
while(lst)
{
if (lst->node==begin->node)
mat[i++][lst->node-1]=2;
else
{
mat[i][lst->node-1]=1;
mat[i++][begin->node-1]=-1;
}
lst=lst->next;
}
begin=begin->next;

• Afișarea ca matrice de adiacență

Pentru aceasta, am creat o funcție show_matad. Apoi declar o matrice 2d patratică: int
**mat, cărieia ulterior îi atribui funcția get_matad, prin care în cazul în care valoarea
vârfului inițial va coincide cu numărul unei linii și valoarea vârfului final cu număru unei
coloane, intersecției liniei și coloanei respective i se atribuia valoarea 1:
while(begin){

lst=begin->bow;

while(lst){

mat[begin->node-1][lst->node-1]=lst->weight;
lst=lst->next; }
begin=begin->next; }

astfel parcurgând întraga matrice.

void show_matadc(t_graph *begin)
{
int n;
int **mat;

submenu("\nAfisarea grafului ca matricea de adiacenta");

if(!begin)
{
ft_error("Graful este vid!");
return;
}
mat=get_matadc(begin, &n);
ft_showmat(mat, n, n, 'X');
ft_freemat(&mat, n);
}
 • Afișarea ca listă de adiacență
Pentru aceasta am creat o funcție show_list, în care se va printa vîrful inițial, iar
imediat după el, vîrfurile în care pleacă vârful initial, separate prin ` `. Atunci când se va
ajunge la elementul nul, 0, se va considera sfârșit de rând și se va printa \n, după care se
va lua vîrful următor, și așa pînă la afișarea tuturor vîrfurilor și conexiunilor dintre ele:
while (begin)
{
SetColor(MAGENTA);
printf("%3d: ",begin->node);
SetColor(WHITE);
t=begin->bow;
while(t) {
ft_putnbr(t->node);
putchar(' ');
t=t->next;
}
ft_putnbr(0);
putchar('\n');
begin=begin->next;
}

Sarcina nr.3
Redacatare grafului:

a)Ștergerea unui arc

b) Adăugarea unui arc
c) Ștergerea unui vârf
d) Adăugarea unui vârf

a) Ștergerea unui arc

Pentru aceasta am creat funcția del_bow. Inițial introduc sursa( vârful inițial):
putstr("Sursa"):
scanf("%d",&k);

apoi destinația( vârful final):

putstr("Destinatia");
scanf("%d",&k);

în cazul dacă astfel de arc există, trecem la funcția list_del(&(t->bow),k):

t=*begin;
if((*begin)->node==node)
{
*begin=(*begin)->next;
free(t);
}
Prin care în cazul în care se va găsi acest arc, el va fi șters.
b) Adaugarea unui arc
Pentru aceasta am creat funcția add_bow. Inițial introduc sursa( vârful inițial), apoi destinația( vârful
final):
puts("Sursa: ");
scanf("%d", &k);
putstr("Destinatia:");
scanf("%d",&k);

dacă vârful sursă nu va fi depistat, se va afișa eroarea : ”nod inexistent”, în caz contrar trecem la
funcția list_add:
if(*begin)
{ g=*begin;
while (g->next)
g=g->next;
g->next=t; }
prin care se reverifică ordinea tuturor vârfurilor sursă, și se va readăuga arcul nou introdus.

c)Ștergerea unui vîrf

Pentru aceasta am creat funcția del_node. Introducem vârful ce dorim să fie șters:
putstr("Nr.de varfuri: ");
scanf("%d",&node);
găsim acest vârf cu ajutorul funcție find_node, după ce vîrful va fi găsit, el va fi șters, iar poziția
celorlalte vârfuri se va muta cu o poziție în urmă:
g=t->next;
free_node(begin, &t);
while(g){

(g->node)--;
g=g->next;
}

d) Adăugarea unui vârf

Pentru aceasta, am creat funcția add_node,
while(t){ t=t->next;
i++;}
care va adăuga un nod la sfârșitul grafului.
void add_node(t_graph **begin)
{ int i=1;
t_graph *t;
submenu ("\nAdaugarea varfului:");
t=*begin;
while(t){ t=t->next; i++;}
graph_add(begin,i); SUCCES;}
Concluzii
Această lucrare de laborator are scopul de a înțelege metode de stocare și modificare a informației
în grafuri.
În cadrul primei sarcini am efectuat introducerea de la tastatură a unui graf prin citirea sa în cele
trei forme, și anume: matrice de adiacență, matrice de incidență și listă de adiacență.
 În cadrul sarcinii numărul doi, am afișat graful introdus anterior,în cele 3 forme posibile: matrice
de adiacență, matrice de incidență și listă de adiacență, respectiv, am efectual convertirea dintr-o
formă în alta.
Sarcina nr 3 constă în editarea grafului. În cadrul ei am șters/adăugat un vârf/muchie.

În urma lucrării la sarcinile lucrăriii de laborator, concluzionez că reprezentarea grafurilor prin

intermediul listelor permite utilizarea mai eficace a memoriei calculatorului, însă aceste forme sunt
mai complicate atât în realizare, cât şi în timpul procesării.

Această lucrare de laborator a avut un rol important în procesul de studiere a materialelor teoretice
la matematica discretă, precum și în studierea aprofundată a limbajului de programare C. Totuși cel
mai semnificativ impact rămâne îmbunătățirea gândirii și a logicii, ce poate fi aplicată ulterior în
toate domeniile posibile.
Anexa
Listingul programului
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define p1 printf("Introdu numarul de arce: ");
#define s1 scanf("%d",&u);
#define p2 printf("Introdu numarul de virfuri: ");
#define s2 scanf("%d",&x);
typedef struct{
int inc;
int sfr;
}arc;
//functia pentru alocarea a memoriei dinamice
int** aloc(int n,int m){
int **vect=NULL;
int i;
vect=(int**)malloc(n*sizeof(int*));
if(vect==NULL)
return vect;
for(i=0;i<n;i++){
vect[i]=(int*)malloc(m*sizeof(int));
if(vect[i]==NULL)
return NULL;
}
return vect;
}
//functia pentru eliberarea a memoriei dinamice
int** freemem(int **vect,int n){
int i;
if(vect==NULL)
return vect;
for(i=0;i<n;i++)
free(vect[i]);
free(vect);
vect=NULL;
return vect;
}
//functia pentru introducere manuala a arcelor
void intro1(arc *a,int u,int x){
int i;
for(i=0;i<u;i++){
in:system("cls");
printf("Introdu datele arcului %d\n",i+1);
printf("Introdu inceputul: X");
scanf("%d",&a[i].inc);
printf("Introdu sfirsitul: X");
scanf("%d",&a[i].sfr);
if(!(a[i].inc >=1 && a[i].inc <= x && a[i].sfr >=1 && a[i].sfr <= x)){
printf("\a\nAti introdus virfuri care nu exista!\nIncercati din nou\n\n");
system("pause");
goto in;
}
 }
}
//functia pentru introducere manuala a matricei de incidenta
void intro2(int **tab_1,int u,int x){
int i,j;
for(i=0;i<u;i++){
printf("Matricea de incidenta:\n");
printf("Rindul %d\n\n",i+1);
for(j=0;j<x;j++){
er: printf("[U%d][X%d]=",i+1,j+1);
scanf("%d",&tab_1[i][j]);
if(!(tab_1[i][j]>=-1 && tab_1[i][j]<=2)){
printf("\a\n\nMatricea de incidenta poate sa contina doar ( -1, 0 , 1, 2 )\n");
printf("Incercati din nou!\n");
system("pause");
system("cls");
goto er;
}
}
system("cls");
}
printf("Introducerea sa efectuat cu succes!\a\n");
}
//functia pentru introducere manuala a matricei de adiacenta
void intro3(int **tab_2,int x){
int i,j;
for(i=0;i<x;i++){
printf("Matricea de adiacenta:\n");
printf("Rindul %d\n\n",i+1);
for(j=0;j<x;j++){
printf("[X%d][X%d]=",i+1,j+1);
scanf("%d",&tab_2[i][j]);
}
system("cls");
}
printf("Introducerea sa efectuat cu succes!\a\n");
}
//functia pentru introducere manuala a listei de adiacenta
void intro4(int **tab_3,int x){
int i,j;
for(i=0;i<x;i++){
printf("Lista de adiacenta:\n");
printf("Rindul %d\n\n",i+1);
printf("%d\n-\n",i+1);
tab_3[i][0]=i+1;
for(j=1;j<x+2;j++){
scanf("%d",&tab_3[i][j]);
if(tab_3[i][j] == 0)
break;
}
system("cls");
}
printf("Introducerea sa efectuat cu succes!\a\n");
}
//functia matrice de incidenta --> arce
void inc_arc(arc *a,int **tab_1,int u,int x){
int i,j;
for(i=0;i<u;i++){
for(j=0;j<x;j++){
if(tab_1[i][j]==-1)
 a[i].inc=j+1;
if(tab_1[i][j]==1)
a[i].sfr=j+1;
if(tab_1[i][j]==2){
a[i].inc=j+1;
a[i].sfr=j+1;
}
}
}
}
//functia matrice de adiacenta --> arce
void ad_arc(arc *a,int **tab_2,int x){
int i,j,l=0;
for(i=0;i<x;i++){
for(j=0;j<x;j++){
if(tab_2[i][j]==1){
a[l].inc=i+1;
a[l].sfr=j+1;
l++;
}
}
}
}
//functia lista de adiacenta --> arce
void li_arc(arc *a,int **tab_3,int x){
int i,j,l=0;
for(i=0;i<x;i++){
for(j=1;j<x+2;j++){
if(tab_3[i][j]!=0){
a[l].inc=i+1;
a[l].sfr=tab_3[i][j];
l++;
} else
break;
}
}
}
//functia pentru afisarea arcelor
void afisare_1(arc *a,int u){
int i;
for(i=0;i<u;i++){
printf("Datele arcului %d\n",i+1);
printf(" X%d --> X%d\n\n",a[i].inc,a[i].sfr);
}
}
//functia pentru afisarea matricelor
void afisare_2(int **vect,int n, int m){
int i,j;
for(i=0;i<n;i++){
for(j=0;j<m;j++)
printf("\t%d",vect[i][j]);
printf("\n\n");
}
}
//functia pentru afisarea listei
void afisare_li(int **vect,int n,int m){
int i,j;
for(i=0;i<n;i++){
printf("%d |",vect[i][0]);
for(j=1;j<m;j++){
 printf(" %d",vect[i][j]);
if(vect[i][j]==0)
break;
}
printf("\n\n");
}
}
//functia pentru matricea de incidenta
void matr_inc(arc *a,int **vect,int u,int x){
int i,j;
for(i=0;i<u;i++){
for(j=0;j<x;j++){
if(a[i].inc==a[i].sfr && a[i].inc==j+1)
vect[i][j]=2;
else
if(a[i].inc==j+1)
vect[i][j]=-1;
else
if(a[i].sfr==j+1)
vect[i][j]=1;
else
vect[i][j]=0;
}
}
}
//functia pentru matricea de adiacenta
void matr_ad(arc *a,int **vect,int u,int x){
int i,j,l,k=0;
for(i=0;i<x;i++){
for(j=0;j<x;j++){
for(l=0;l<u;l++){
if(a[l].inc==i+1 && a[l].sfr==j+1){
vect[i][j]=1;
k++;
}
}
if(!k)
vect[i][j]=0;
k=0;
}
}
}
//functia pentru lista de incidenta
void list_inc(arc *a,int **tab_3,int u,int x){
int i,j,l,k=1;
for(i=0;i<x;i++){
tab_3[i][0]=i+1;
k=1;
for(j=1;j<x+1;j++){
for(l=0;l<u;l++){
if(a[l].inc==i+1 && a[l].sfr==j){
tab_3[i][k]=j;
k++;
}
}
}
tab_3[i][k]=0;
}
}
//functia pentru modificare a datelor arcelor
void modif(arc *a,int ar){
printf("Datele arcului %d",ar);
printf(" X%d --> X%d\n\n",a[ar-1].inc,a[ar-1].sfr);
printf("Introdu inceputul: X");
scanf("%d",&a[ar-1].inc);
printf("Introdu sfirsitul: X");
scanf("%d",&a[ar-1].sfr);
}
//citirea din fisier a arcelor
void read_ar(arc *a,FILE *demo){
int i=0;
while(!feof(demo)){
fscanf(demo,"%d%d",&a[i].inc,&a[i].sfr);
i++;
}
printf("\a\nCitirea a avut loc cu succes!\n\n");
}
//citirea din fisier a matr. de incidenta/adiacenta
void read_matr(int **vect,FILE *demo,int n,int m){
int i=0,j=0;
while((!feof(demo)) && i<n){
while(j<m){
fscanf(demo,"%d",&vect[i][j]);
j++;
}
i++;
j=0;
}
printf("\a\nCitirea a avut loc cu succes!\n\n");
}
//citirea din fisier a listei de adiacenta
void read_li(int **vect,FILE *demo,int n){
int i=0,j=0;
while((!feof(demo)) && i<n){
while(vect[i][j-1]!=0){
fscanf(demo,"%d",&vect[i][j]);
j++;
}
i++;
j=0;
}
printf("\a\nCitirea a avut loc cu succes!\n\n");
}
//functia pentru salvare in fisier a arcelor
void save(arc *vect,char *fname,int u,int x){
int i;
FILE *demo=fopen(fname,"w");
fprintf(demo,"%d %d",u,x);
for(i=0;i<u;i++)
fprintf(demo,"\n%d %d",vect[i].inc,vect[i].sfr);
fclose(demo);
}
//functia pentru salvare a matricelor de incidenta
void save_1(int **tab_1,char *fname,int u,int x){
int i,j;
FILE *demo=fopen(fname,"w");
fprintf(demo,"%d %d",u,x);
for(i=0;i<u;i++){
fprintf(demo,"\n");
for(j=0;j<x;j++)
 fprintf(demo,"%d ",tab_1[i][j]);
}
fclose(demo);
}
//functia pentru salvare a matricelor de adiacenta
void save_2(int **tab_2,char *fname,int u,int x){
int i,j;
FILE *demo=fopen(fname,"w");
fprintf(demo,"%d %d",u,x);
for(i=0;i<x;i++){
fprintf(demo,"\n");
for(j=0;j<x;j++)
fprintf(demo,"%d ",tab_2[i][j]);
}
fclose(demo);
}
//functia pentru salvare a listei de adiacenta
void save_3(int **vect,char *fname,int u,int x){
int i,j;
FILE *demo=fopen(fname,"w");
fprintf(demo,"%d %d",u,x);
for(i=0;i<x;i++){
fprintf(demo,"\n");
for(j=0;j<x+2;j++){
fprintf(demo,"%d ",vect[i][j]);
if(vect[i][j]==0)
break;
}
}
fclose(demo);
}
/
**********************************************************************************************
***/
int main(){
arc *a=NULL; //tablou unidimensional de tip structura pentru arce
int **tab_1=NULL,**tab_2=NULL,**tab_3=NULL; //tablou bidimensional pentru matrice
int i,u=0,x=0,ar,m=1;
int com1,com2,com3;
char filename[20];
FILE *demo;
while(1){ /* Meniul pentru introducere a datelor */
while(m){ m=0;
system("cls");
printf("Home:\n\n");
printf(" Introducerea manula:\n\n");
printf("[ 1 ] Introdu arcele\n");
printf("[ 2 ] Introdu matricea de incidenta\n");
printf("[ 3 ] Introdu matricea de adiacenta\n");
printf("[ 4 ] Introdu lista de adiacenta\n");
printf("\n Citire din fisier:\n\n");
printf("[ 5 ] Arcele\n");
printf("[ 6 ] Matricea de incidenta\n");
printf("[ 7 ] Matricea de adiacenta\n");
printf("[ 8 ] Lista de adiacenta\n\n");
printf("[ 0 ] Iesire\n");
printf("\nComanda << ");
scanf("%d",&com1);
system("cls");
switch(com1){
case 0:
exit(0);
break;
case 1:
p1 s1 p2 s2
system("cls");
a=(arc*)malloc(u*sizeof(arc));
intro1(a,u,x);
break;
case 2:
p1 s1 p2 s2
system("cls");
tab_1=aloc(u,x);
intro2(tab_1,u,x);
break;
case 3:
p1 s1 p2 s2
system("cls");
tab_2=aloc(x,x);
intro3(tab_2,x);
break;
case 4:
p1 s1 p2 s2
system("cls");
tab_3=aloc(x,x+2);
intro4(tab_3,x);
break;
case 5:
printf("Introdu numele fisierului (extensia este pusa automat .arc)\n");
scanf("%s",&filename);
strcat(filename,".arc");
demo=fopen(filename,"rt");
if(demo==NULL){
printf("\n\aEroare la deschiderea fisierului!\n");
printf("\n1) Posibil fisierului nu a fost gasit!");
printf("\n2) Posibil extensia fisierului nu este corecta!\n\n");
m=1;
} else {
fscanf(demo,"%d%d",&u,&x);
a=(arc*)malloc(u*sizeof(arc));
read_ar(a,demo);
afisare_1(a,u);
fclose(demo);
}
break;
case 6:
printf("Introdu numele fisierului (extensia este pusa automat .in)\n");
scanf("%s",&filename);
strcat(filename,".in");
demo=fopen(filename,"rt");
if(demo==NULL){
printf("\n\aEroare la deschiderea fisierului!\n");
printf("\n1) Posibil fisierului nu a fost gasit!");
printf("\n2) Posibil extensia fisierului nu este corecta!\n\n");
m=1;
} else {
fscanf(demo,"%d%d",&u,&x);
tab_1=aloc(u,x);
read_matr(tab_1,demo,u,x);
afisare_2(tab_1,u,x);
 fclose(demo);
}
break;
case 7:
printf("Introdu numele fisierului (extensia este pusa automat .ad)\n");
scanf("%s",&filename);
strcat(filename,".ad");
demo=fopen(filename,"rt");
if(demo==NULL){
printf("\n\aEroare la deschiderea fisierului!\n");
printf("\n1) Posibil fisierului nu a fost gasit!");
printf("\n2) Posibil extensia fisierului nu este corecta!\n\n");
m=1;
} else {
fscanf(demo,"%d%d",&u,&x);
tab_2=aloc(x,x);
read_matr(tab_2,demo,x,x);
afisare_2(tab_2,x,x);
fclose(demo);
}
break;
case 8:
printf("Introdu numele fisierului (extensia este pusa automat .li)\n");
scanf("%s",&filename);
strcat(filename,".li");
demo=fopen(filename,"rt");
if(demo==NULL){
printf("\n\aEroare la deschiderea fisierului!\n");
printf("\n1) Posibil fisierului nu a fost gasit!");
printf("\n2) Posibil extensia fisierului nu este corecta!\n\n");
m=1;
} else {
fscanf(demo,"%d%d",&u,&x);
tab_3=aloc(x,x+2);
read_li(tab_3,demo,x);
afisare_li(tab_3,x,x);
fclose(demo);
}
break;
default:
printf("\aAti introdus o comanda gresita! { %d }\n",com1);
m=1;
break;
}
if(a==NULL){
a=(arc*)malloc(u*sizeof(arc));
if(tab_1!=NULL)
inc_arc(a,tab_1,u,x); //convertarea din matr. de incidenta in arce
else
if(tab_2!=NULL)
ad_arc(a,tab_2,x); //convertarea din matr. de adiacenta in arce
else
if(tab_3!=NULL)
li_arc(a,tab_3,x); //convertarea din lista de adiacenta in arce
}
system("pause");
}
/* Meniul afisare/salvare/modificare */
system("cls");
printf("Meniu:\n\n");
printf("[ 1 ] Afisarea arcelor\n");
printf("[ 2 ] Modificarea arcelor\n\n");
printf("[ 3 ] Matricea de incidenta\n");
printf("[ 4 ] Matricea de adiacenta\n");
printf("[ 5 ] Lista de incidenta\n\n");
printf("[ 6 ] Salveaza in fisier\n\n");
printf("[ 0 ] Iesire\n");
printf("\nComanda << ");
scanf("%d",&com2);
system("cls");
switch(com2){
case 0:
if(a)
free(a);
if(tab_1)
tab_1=freemem(tab_1,u);
if(tab_2)
tab_2=freemem(tab_2,x);
if(tab_3)
tab_3=freemem(tab_3,x+2);
exit(0);
break;
case 1:
afisare_1(a,u);
break;
case 2:
lm: system("cls");
afisare_1(a,u);
printf("\n\nIntrodu numarul arcului pentru modificare: ");
scanf("%d",&ar);
if(!(ar >= 1 && ar <= u)){
system("cls");
printf("\aArcul introdus nu exista! Incercati din nou.\n");
system("pause");
goto lm;
}
system("cls");
modif(a,ar);
break;
case 3:
printf("Matricea de incidenta:\n\n");
if(tab_1){
afisare_2(tab_1,u,x);
}
else{
tab_1=aloc(u,x);
matr_inc(a,tab_1,u,x);
afisare_2(tab_1,u,x);
}
break;
case 4:
printf("Matricea de adiacenta:\n\n");
if(tab_2){
afisare_2(tab_2,u,x);
}
else{
tab_2=aloc(x,x);
matr_ad(a,tab_2,u,x);
afisare_2(tab_2,x,x);
}
 break;
case 5:
printf("Lista de incidenta:\n\n");
if(tab_3!=NULL){
afisare_li(tab_3,x,x+2);
} else {
tab_3=aloc(x,x+2);
list_inc(a,tab_3,u,x);
afisare_li(tab_3,x,x+2);
}
break;
case 6:
printf("Save menu:\n\n");
printf("[ 1 ] Salveaza Arcele\n");
printf("[ 2 ] Salveaza Matricea de incidenta\n");
printf("[ 3 ] Salveaza Matricea de adiacenta\n");
printf("[ 4 ] Salveaza Lista de adiacenta\n");
printf("\n Comanda << ");
scanf("%d",&com3);
system("cls");
switch(com3){
case 1:
printf("Salveaza Arcele:\n\n");
printf("Introduceti numele fisierului pentru salvare\n");
scanf("%s",&filename);
strcat(filename,".arc");
save(a,filename,u,x);
break;
case 2:
if(!tab_1){
printf("\aMai intii converteaza!\n");
} else {
printf("Salveaza Matricea de incidenta:\n\n");
printf("Introduceti numele fisierului pentru salvare\n");
scanf("%s",&filename);
strcat(filename,".in");
save_1(tab_1,filename,u,x);
}
break;
case 3:
if(!tab_2){
printf("\aMai intii converteaza!\n");
} else {
printf("Salveaza Matricea de adiacenta:\n\n");
printf("Introduceti numele fisierului pentru salvare\n");
scanf("%s",&filename);
strcat(filename,".ad");
save_2(tab_2,filename,u,x);
}
break;
case 4:
if(!tab_3){
printf("\aMai intii converteaza!\n");
} else {
printf("Salveaza Lista de adiacenta:\n\n");
printf("Introduceti numele fisierului pentru salvare\n");
scanf("%s",&filename);
strcat(filename,".li");
save_3(tab_3,filename,u,x);
}
 break;
default:
printf("\aAti introdus o comanda gresita! { %d }\n",com2);
break;
}
break;
default:
printf("\aAti introdus o comanda gresita! { %d }\n",com2);
break;
}
system("pause");
}
return 0;
}

Bibliografie

V.Beșliu „Matematica Discretă.Ciclu de prelegeri”, Chișinău,2002

T.Brânzaru Matematici Speciale, București,1981