Sdaawa

Portofoliu S.D.A.
Popa Alexandru Gabriel

314AB
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct node
{
char c;
struct node *next; .
struct node *prev;
};
typedef struct node nod;
struct lista_capete
{
nod *capCurent;
nod *capNext;
};
typedef struct lista_capete capete;
struct curs
{
int pozitie_cursor;
struct curs *next;
};
typedef struct curs cursor;
struct undoRedo
{
capete *capCopie;
cursor *capCursor;
unsigned int lenght;
};
typedef struct undoRedo stiva;
void citire_text(FILE *f,char nume[],nod **CapDeLista)

{
nod *p,*q;
char c;
f = fopen(nume,"rb");
if(f == NULL)
{
printf("Fisierul date.in nu a putut fi deschis!\n");
exit(1);
}
*CapDeLista = (nod*)malloc(sizeof(nod));
2
p = (nod*)malloc(sizeof(nod));
if((c = fgetc(f)) != EOF)
{
(*CapDeLista)->next = p;
(*CapDeLista)->prev = NULL;
p->prev = *CapDeLista;
p->c = c;
p->next = NULL;
}
while((c = fgetc(f)) != EOF)
{
q = (nod*)malloc(sizeof(nod));
q->c = c;
p->next = q;
q->next = NULL;
q->prev = p;
p = q;
}
fclose(f);
}
void move(nod **cursor,int n)

{
int i;
if(n > 0)
{
for(i=0;i<n;i++)
{
if((*cursor)->next != NULL)
(*cursor) = (*cursor)->next;
}
}
else if(n < 0)
{
for(i=0;i<-n;i++)
{
if((*cursor)->prev != NULL)
(*cursor) = (*cursor)->prev;
}
}
}
void insert_string(nod **cursor, char *string)

{
3
int i,n;
nod *p;
n = strlen(string);
for(i=0;i<n;i++)
{
if((*cursor)->next != NULL)
{
p->next = (*cursor)->next;
(*cursor)->next->prev = p;
(*cursor)->next = p;
p->prev = *cursor;
p->c = string[i];
(*cursor) = p;
}
else
{
p->next = NULL;
p->c = string[i];
(*cursor)->next = p;
p->prev = (*cursor);
(*cursor) = p;
}
}
}
void sterge_n(nod *cursor,int n)

{
int i;
nod *aux;
for(i=0;i<n;i++)
{
if(cursor->next->next)
{
aux = cursor->next;
cursor->next->next->prev = cursor;
cursor->next = cursor->next->next
free(aux);
}
else if(cursor->next)
{
aux = cursor->next;
cursor->next = NULL;
4
free(aux);
break;
}
}
}
void copy_n(nod *cursor,int n,char **buffer)

{
int i;
(*buffer) = (char*)malloc(n*sizeof(char));
for(i=0;i<n;i++)
{
if(cursor->next != NULL)
{
(*buffer)[i] = cursor->next->c;
cursor = cursor->next;
}
}
(*buffer)[i]='\0';
}
void paste(nod **cursor,char buffer[])
{
insert_string(cursor,buffer);
}
void backspace(nod **cursor)
{
nod *aux;
if((*cursor)->c && (*cursor)->next != NULL)
{
aux = (*cursor);
(*cursor)->prev->next = (*cursor)->next;
(*cursor)->next->prev = (*cursor)->prev;
free(aux);
}
else if((*cursor)->c)
{
aux = (*cursor);
(*cursor)->prev->next = NULL;
free(aux);
}
}
5
stiva *creeaza_stiva()
{
stiva *stack;
stack = (stiva*)malloc(sizeof(stiva));
stack->lenght = 0;
stack->capCopie = (capete*)malloc(sizeof(capete));
stack->capCopie->capCurent = NULL;
stack->capCopie->capNext = NULL;
stack->capCursor = NULL;
return stack;
}
int copiaza_lista(nod *cap,nod **capcopy)

{
nod *p,*q,*w;
if(cap != NULL)
{
(*capcopy) = (nod*)malloc(sizeof(nod));
(*capcopy)->next = p;
(*capcopy)->prev = NULL;
w = cap;
w = w->next;
p->prev = (*capcopy);
p->c = w->c;
p->next = NULL;
w = w->next;
while(w != NULL)
{
q = (nod*)malloc(sizeof(nod));
q->c = w->c;
q->prev = p;
q->next = NULL;
p->next = q;
p = q;
w = w->next;
}
}
}
void push_stiva(stiva *stack,nod *cap,int pozitie_cursorr)
{
nod *capDel,*p;
6
cursor *crs;
int i;
capDel = (nod*)malloc(sizeof(nod));
crs = (cursor*)malloc(sizeof(cursor));
copiaza_lista(cap,&capDel);
if(stack->capCursor == NULL)
{
crs->pozitie_cursor = pozitie_cursorr;
crs->next = NULL;
stack->capCursor = crs;
}
else
{
crs->next = stack->capCursor;
crs->pozitie_cursor = pozitie_cursorr;
stack->capCursor = crs;
}
if (stack->capCopie->capCurent == NULL)
{
stack->capCopie->capNext = NULL;
stack->capCopie->capCurent = capDel;
}
else
{
stack->capCopie->capNext = stack->capCopie->capCurent;
stack->capCopie->capCurent = capDel;
}
stack->lenght++;
}
int pop_stiva(stiva *stack,nod **cap,int *pozitie)

{
if(stack->lenght > 0)
{
copiaza_lista(stack->capCopie->capCurent,&(*cap));
(*pozitie) = stack->capCursor->pozitie_cursor;
if(stack->capCopie->capNext != NULL && stack->capCursor->next != NULL)
{
stack->capCopie->capCurent = stack->capCopie->capNext;
stack->capCursor = stack->capCursor->next;
}
stack->lenght--;
}
else return 0;
7
}
void find_replace(nod *cap,char *cuvant1,char *cuvant2)

{
int i,nr = strlen(cuvant1),k;
nod *p,*q;
p = cap;
while(p->next != NULL)
{
if(p->next->c == cuvant1[0])
{
k = 1;
q = p->next->next;
for(i=1;q != NULL,q->next != NULL,i<nr;i++)
{
if(cuvant1[i] == q->c)
k++;
else break;
q = q->next;
}
if (k == nr)
{
sterge_n(p,nr);
insert_string(&(p),cuvant2);
}
}
p = p->next;
}
}
void free_mem(nod *cap,stiva *undo,stiva *redo)

{
nod *p,*aux;
int degeaba;
p = cap;
while(p)
{
aux = p;
p = p->next;
free(aux);
}
while(pop_stiva(undo,&cap,&degeaba) != 0)
{
8
p = cap;
while(p)
{
aux = p;
p = p->next;
free(aux);
}
}
while(pop_stiva(redo,&cap,&degeaba) != 0)
{
p = cap;
while(p)
{
aux = p;
p = p->next;
free(aux);
}
}
}
int main(int argc,char ** argv)

{
FILE *f;
nod *CapDeLista,*cursor,*p;
char *buffer,*operatie,*deInserat;
char *cuvant,*cuvant_nou;
cuvant = (char*)malloc(16*sizeof(char));
cuvant_nou = (char*)malloc(16*sizeof(char)); .
int i,nr,pozitie_cursor = 0,poz2;
stiva *undo,*redo;
citire_text(f,argv[1],&CapDeLista);
cursor = CapDeLista;
undo = creeaza_stiva();
redo = creeaza_stiva();
f = fopen(argv[2],"rt");
if(f == NULL)
{
printf("Fisierul de operatii nu a putut fi deschis!\n");
exit(1);
}
fscanf(f,"%d",&nr);
while((fscanf(f,"%s",operatie)) != EOF)
9
{
if(strcmp(operatie,"del") == 0)
{
push_stiva(undo,CapDeLista,pozitie_cursor);
fscanf(f,"%d",&nr);
sterge_n(cursor,nr);
}
else if(strcmp(operatie,"move") == 0)
{
fscanf(f,"%d",&nr);
pozitie_cursor = pozitie_cursor + nr;
move(&cursor,nr);
}
else if(strcmp(operatie,"copy") == 0)
{
fscanf(f,"%d",&nr);
copy_n(cursor,nr,&buffer);
}
else if(strcmp(operatie,"paste") == 0)
{
pozitie_cursor = pozitie_cursor + strlen(buffer);
paste(&cursor,buffer);
}
else if(strcmp(operatie,"insert") == 0)
{
fscanf(f,"%s",deInserat);
pozitie_cursor = pozitie_cursor + strlen(deInserat);
insert_string(&cursor,deInserat);
}
else if(strcmp(operatie,"backspace") == 0)
{
pozitie_cursor = pozitie_cursor - 1;
backspace(&cursor);
}
else if(strcmp(operatie,"undo") == 0)
{
push_stiva(redo,CapDeLista,pozitie_cursor);
pop_stiva(undo,&CapDeLista,&poz2);pozitie_cursor = poz2;
move(&cursor,poz2);
10
}
else if(strcmp(operatie,"redo") == 0)
{
pop_stiva(redo,&CapDeLista,&poz2);
pozitie_cursor = poz2;
move(&cursor,poz2);
}
else if(strcmp(operatie,"replace") == 0)
{
fscanf(f,"%s",cuvant);
fscanf(f,"%s",cuvant_nou);
push_stiva(redo,CapDeLista,pozitie_cursor);
find_replace(CapDeLista,cuvant,cuvant_nou);
}
}
fclose(f);
f = fopen(argv[3],"wt");
if(f == NULL)
{
printf("Fisierul rezultat.out nu a putut fi creat!\n");
exit(1);
}
p = CapDeLista->next;
while(p != NULL)
{
fprintf(f,"%c",p->c);
p = p->next;
}
fclose(f);
free(cuvant);
free(cuvant_nou);
free_mem(CapDeLista,undo,redo);
return 0;
}
11
/* arbrecc.c - arbore, construit recursiv, ce contine cuvinte, si numarul
de aparitie a acestora, citite de la tastatura (cate un cuvant pe linie)
introducerea cuvintelor se termina cu un cuvant vid (Enter la inceputul
liniei), si apoi sunt afisate cuvintele in ordine alfabetica */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define LUNGMAX 20
struct st_arbore
{
char *cuvant; /* pointer la cuvantul citit */
int nrap; /* numarul de aparitii */
struct st_arbore *st, *dr;
};
int nle=0;
void actualizare (struct st_arbore * arb , char *cuv){

/* Functia actualizeaza arborele binar.
Daca cuvantul nu a mai fost citit se creaza un nou nod,
12
altfel se incrementeaza contorul de aparitii al
nodului corespunzator cuvantului citit anterior.
Se determina pe care ramura a arborelui se va insera
cuvantul, sau daca exista deja
*/
if (strcmp(cuv, arb->cuvant) < 0)
if (arb->st)
actualizare (arb->st, cuv);
else {
arb->st=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
arb=arb->st;
arb->cuvant=cuv;
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
}
else if (strcmp(cuv, arb->cuvant) >0 )
if(arb->dr)
actualizare (arb->dr, cuv);
else {
arb->dr=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
arb=arb->dr;
arb->cuvant=cuv;
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
}
else
arb->nrap=arb->nrap + 1;
}
void tiparire_arbore (struct st_arbore *arbo)

/* functia afiseaza arborele de cautare ce contine cuvinte si
numarul lor de aparitii */
{
if (arbo!=NULL)
{
tiparire_arbore (arbo->st) ; /* tiparire arbore stanga */
printf ("%s (ap: %d)\n", arbo -> cuvant, arbo -> nrap ) ;
nle++;
if (nle%24==0){
printf("Apasati o tasta pentru a continua afisarea!\n");
getch();
13
}
tiparire_arbore (arbo->dr) ; /* tiparire arbore dreapta */
}
}
void main ()
{struct st_arbore *arb;
char cuvant[LUNGMAX] ;
clrscr();
printf("Introduceti cuvinte, care vor fi apoi tiparite in ordine"
" alfabetica:\n");
gets(cuvant) ;
arb=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
/* am presupus ca nu se returneaza de catre malloc
valoarea NULL */
arb->cuvant=strdup(cuvant);
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
gets(cuvant) ;
while (strcmp(cuvant, ""))
{actualizare (arb, strdup(cuvant));
gets(cuvant);
}
printf("Lista ordonata a cuvintelor (numar aparitii):\n");
tiparire_arbore (arb);
}
/* coadacuv.c - programul construieste o coada de cuvinte,

pe care o afiseaza, la terminarea introducerii de cuvinte,
cu eliberarea spatiului alocat pentru aceasta structura */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMCV 25
struct st_cuvant
{
char *cuvant; /* pointer la sirul de caractere (cuvant) */
struct st_cuvant *urmator;
};
int ncl=0; /* numar de cuvinte afisate pe linie */
14
struct st_cuvant * atasare_coada (struct st_cuvant *ultim, char *sirc)
{
struct st_cuvant *vr;
vr=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
if (vr) /* daca s-a putut crea un pointer se continua atasarea */
{
vr->cuvant=strdup(sirc);
vr->urmator=NULL;
ultim->urmator=vr;
}
return (vr);
}
void extragere ( struct st_cuvant * primu)

{
struct st_cuvant *ptr;
while (primu)
{ptr=primu; /* memorat pentru a elibera spatiul referit de el */
printf (" %s -> ", primu->cuvant);
ncl++;
if (ncl%5==0)
printf("\n");
primu=primu->urmator;
free(ptr); /* eliberarea spatiului alocat pointerului */
}
printf ("NULL\n");/* sfarsit lista sau lista vida daca primu == NULL */
}
void main()
{
struct st_cuvant *primul, *ultimul;
char cuv[DIMCV];
clrscr();
printf("Programul construieste o lista de tip coada cu cuvinte de la"
" tastatura\n");
printf("Programul ia sfarsit cu un cuvant vid, adica RETURN,"
" la inceput de linie.\n");
printf("Cuvant de introdus in lista:");
gets(cuv);
primul=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
primul->cuvant=strdup(cuv);
primul->urmator=NULL;
ultimul=primul;
15
gets(cuv);
while (strcmp(cuv, SIR_VID))
{
if(!(ultimul=atasare_coada (ultimul, cuv)))
break;
gets(cuv);
}
extragere (primul);
}
/* coadatab.c - operatii cu o coada realizata static intr-un tablou;

operatii disponibile: inserare, extragere, afisare cap coada,
afisare coada, afisare pozitii referinte la primul si ultimul
element din coada */
#include <stdio.h>
#include <conio.h>
#define MaxC 10
typedef int ElTip; // ElTip - definire tip element din coada

typedef struct {
ElTip elem [MaxC];// spatiu pentru elem. cozii
int prim, ultim;
/* indecsi/ referinte la primul/ ultimul element din coada */
} TCoada, *ACoada;
void eroare (char *meserr){

printf("%s\n", meserr);
}
int IncIndexC (int i){ /* increment index element curent coada */

return ((i+1) % MaxC);
}
void InitCoada (ACoada pc){

/* initializare coada, referintele prim si ultim */
pc->prim=0;
pc->ultim=MaxC-1;
}
int CoadaGoala (ACoada pc){

/* coada este goala: index (ultim+1) == index (prim)
coada goala: x x x x u p x x x x ,
16
daca p si u ocupa aceeasi pozitie coada are un singur element:
x x x x x p(u) x x x x , p si u au aceeasi valoare */
return (IncIndexC (pc->ultim) == pc->prim);
}
int CoadaPlina (ACoada pc){

/* coada este plina: index (ultim+2) == index (prim)
coada goala: x x x u - p x x x x , pozitia - nu este element in coada*/
return (IncIndexC (IncIndexC(pc->ultim)) == pc->prim);
}
void AdaugElC (ACoada pc, ElTip el){

if (IncIndexC (IncIndexC(pc->ultim)) == pc->prim)
eroare ("Coada Plina !!!");
else {pc->ultim=IncIndexC(pc->ultim);
pc->elem[pc->ultim]=el;
}
}
ElTip ScotElC (ACoada pc){

ElTip e;
if (CoadaGoala (pc))
{eroare ("Coada Goala !!!");
return 0;
}
else
{e=pc->elem[pc->prim];
pc->prim=IncIndexC(pc->prim);
return e;
}
}
ElTip CapCoada (ACoada pc){

return 0;
}
else
return pc->elem[pc->prim];
}
void AfisareCoada (ACoada pc){

/* se creaza o copie a cozii curente, pentru a utiliza functiile
definite pentru operare coada (ScotElC, CapCoada, CoadaGoala) */
17
TCoada c=*pc;
ACoada pt=&c;
int nvl=0; /* Numar de valori afisate pe linie */
if (CoadaGoala(pt))
eroare("Coada Goala !!!\n");
else
while (!CoadaGoala (pt))
{printf ("%d -> ", CapCoada (pt));
ScotElC (pt);
if (++nvl % 10 == 0)
printf("\n");
}
printf("NULL\n");
}
void Afisare_Poz_Prim_Ultim (ACoada pc){

printf("Cei doi indecsi (referinte), prim si ultim: %d(p), %d(u)\n",
pc->prim, pc->ultim);
}
void main (void){

TCoada c, *pc;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de coada realizata utilizand un tablou.\n");
printf("Coada este alcatuita din numere intregi.\n");
InitCoada (pc);
printf("\nOptiuni Int, Ext, Afis coada, Cap coada, Poz p/u, Stop: ");
gets(optiune);
while (optiune[0] != '\0' && optiune[0] != 's' && optiune[0] != 'S'){
switch(optiune[0]){
case 'i':
case 'I':if (CoadaPlina(pc)){
eroare("\n\tCOADA PLINA !!! ELIMINATI...\n");
break;}
printf("Introd. nr. (CTRL-Z, Enter-Stop Introd): ");
while (scanf("%d", &n) == 1){
AdaugElC (pc, n);
if (CoadaPlina (pc)){
eroare("Coada PLINA !!! ELIMINATI.....\n");
break;
}
18
}
fflush(stdin);
break;
case 'e':
case 'E': optiune[0]='D';
while ( !CoadaGoala (pc) &&
(optiune[0] == 'D' || optiune[0] == 'd') )
{printf ("Se extrage primul element din coada: %d\n",
CapCoada (pc));
ScotElC (pc);
if (!CoadaGoala (pc)){
printf("Continuati extragerea (Da/Nu): ");
gets(optiune);
fflush(stdin);
}
}
printf("Coada Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!CoadaGoala (pc))
printf("Afisare element din capul cozii: %d\n",
CapCoada (pc));
else
break;
case 'a':
case 'A':AfisareCoada (pc);
break;
case 'p':
case 'P': Afisare_Poz_Prim_Ultim (pc);
break;
}
gets(optiune);
}
}
/* coadatbv.c - operatii cu o coada realizata static intr-un tablou;
operatii disponibile: inserare, extragere, afisare cap coada,
afisare coada, afisare pozitii referinte la primul si ultimul
element din coada
Varianta: pentru afisare nu se creaza o copie a cozii, ci se
utilizeaza doi indecsi locali in functia Afisare CoadaV (pc) */
#include <stdio.h>
19
#include <conio.h>
#define MaxC 10
typedef int ElTip; // ElTip - definire tip element din coada

typedef struct {
ElTip elem [MaxC];// spatiu pentru elem. cozii
int prim, ultim;
/* indecsi/ referinte la primul/ ultimul element din coada */
} TCoada, *ACoada;

}
int IncIndexC (int i){ /* increment index element curent coada */

return ((i+1) % MaxC);
}
void InitCoada (ACoada pc){

/* initializare coada, referintele prim si ultim */
pc->prim=0;
pc->ultim=MaxC-1;
}
int CoadaGoala (ACoada pc){

/* coada este goala: index (ultim+1) == index (prim)
coada goala: x x x x u p x x x x ,
daca p si u ocupa aceeasi pozitie coada are un singur element:
x x x x x p(u) x x x x , p si u au aceeasi valoare */
return (IncIndexC (pc->ultim) == pc->prim);
}
int CoadaPlina (ACoada pc){

/* coada este plina: index (ultim+2) == index (prim)
coada goala: x x x u - p x x x x , pozitia - nu este element in coada*/
return (IncIndexC (IncIndexC(pc->ultim)) == pc->prim);
}
void AdaugElC (ACoada pc, ElTip el){

if (IncIndexC (IncIndexC(pc->ultim)) == pc->prim)
eroare ("Coada Plina !!!");
else {pc->ultim=IncIndexC(pc->ultim);
pc->elem[pc->ultim]=el;
}
20
}
ElTip ScotElC (ACoada pc){

ElTip e;
return 0;
}
else
{e=pc->elem[pc->prim];
pc->prim=IncIndexC(pc->prim);
return e;
}
}
ElTip CapCoada (ACoada pc){

return 0;
}
else
return pc->elem[pc->prim];
}
void AfisareCoadaV (ACoada pc){

/* se parcurge coada cu doi indecsi locali, copii ai celor din coada */
int pp, pu; /* indecsi la primul si ultimul din coada */
pp=pc->prim;
pu=pc->ultim;
if (CoadaGoala(pc))
else
while ((pu+1) != pp) /* conditie de coada goala */
{printf ("%d -> ", pc->elem[pp]);
pp++;
if (++nvl % 10 == 0)
printf("\n");
}
printf("NULL\n");
}
void Afisare_Poz_Prim_Ultim (ACoada pc){

printf("Cei doi indecsi (referinte), prim si ultim: %d(p), %d(u)\n",
21
pc->prim, pc->ultim);
}
void main (void){

TCoada c, *pc;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de coada realizata utilizand un tablou.\n");
printf("Coada este alcatuita din numere intregi.\n");
InitCoada (pc);
gets(optiune);
switch(optiune[0]){
case 'i':
case 'I':if (CoadaPlina(pc)){
eroare("\n\tCOADA PLINA !!! ELIMINATI...\n");
break;}
while (scanf("%d", &n) == 1){
AdaugElC (pc, n);
if (CoadaPlina (pc)){
eroare("Coada PLINA !!! ELIMINATI.....\n");
break;
}
}
fflush(stdin);
break;
case 'e':
while ( !CoadaGoala (pc) &&
{printf ("Se extrage primul element din coada: %d\n",
CapCoada (pc));
ScotElC (pc);
if (!CoadaGoala (pc)){
gets(optiune);
fflush(stdin);
}
}
22
printf("Coada Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!CoadaGoala (pc))
printf("Afisare element din capul cozii: %d\n",
CapCoada (pc));
else
break;
case 'a':
case 'A':AfisareCoadaV (pc);
break;
case 'p':
case 'P': Afisare_Poz_Prim_Ultim (pc);
break;
}
gets(optiune);
}
}
/* coadvcuv.c - programul construieste o coada de cuvinte,

pe care o afiseaza, la terminarea introducerii de cuvinte,
cu eliberarea spatiului alocat pentru aceasta structura;
varianta citeste in ciclu si primul cuvant introdus */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMCV 25
struct st_cuvant
{
};
int ncl=0; /* numar de cuvinte afisate pe linie */
struct st_cuvant * atasare_coada (struct st_cuvant *ultim, char *sirc)

{
struct st_cuvant *vr;
vr=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
if (vr) /* daca s-a putut crea un pointer se continua atasarea */
{
23
vr->cuvant=strdup(sirc);
vr->urmator=NULL;
ultim->urmator=vr;
}
return (vr);
}
void extragere ( struct st_cuvant * primu)

{
struct st_cuvant *ptr;
while (primu)
{ptr=primu; /* memorat pentru a elibera spatiul referit de el */
printf (" %s -> ", primu->cuvant);
ncl++;
if (ncl%5==0)
printf("\n");
primu=primu->urmator;
free(ptr); /* eliberarea spatiului alocat pointerului */
}
printf ("NULL\n");/* sfarsit lista sau lista vida daca primu == NULL */
}
void main()
{
struct st_cuvant *primul, *ultimul;
char cuv[DIMCV];
clrscr();
" tastatura\n");
gets(cuv);
primul=ultimul=NULL;
while (strcmp(cuv, SIR_VID))
{
if(!(ultimul=atasare_coada (ultimul, cuv)))
break;
if (!primul)
primul=ultimul;
gets(cuv);
}
extragere (primul);
24
}
/* listcirc.c - programul construieste o lista circulara de caractere,

pe care apoi o tipareste, si in care se cauta un anumit caracter */
#include <stdio.h>
struct st_litera
{
char car;
struct st_litera * pred, *urm;
};
int ncl=0; /* numar de caractere afisate pe linie */
void atasare(struct st_litera *pl){
char c;
struct st_litera *vr;
while ((c=getchar()) != EOF)
if (c!='\n')
{vr=(struct st_litera *) malloc(sizeof(struct st_litera));
if (vr == NULL)
{ /* daca pointerul returnat de functia malloc() este
NULL */
printf("Memorie plina !!!!!!\n"); /* se tipareste un
mesaj de eroare */
break; /* si se termina executia ciclului de citire
caractere */
}
vr->car=c;
if(pl->pred==pl) /* lista vida? */
{vr->pred=vr->urm=pl;
pl->urm=pl->pred=vr;
}
else {vr->urm=pl;
vr->pred=pl->pred;
pl->pred->urm=vr;
pl->pred=vr;
}
}
}
void afis_list_circ (struct st_litera *plc){

struct st_litera *p;
p=plc->urm;
25
while (p != plc)
{printf("%c -> ", p->car);
p=p->urm;
ncl++;
if (ncl%10==0) /* s-au afisat 10 caractere pe linie ? */
printf("\n");
}
if (plc->urm!=plc)
printf("%c (primul).\n", plc->urm->car);/* tiparire primul caracter sau
NULL daca lista este vida */
else
printf("NULL");
}
int numar_aparitii_car (struct st_litera *start, char *pcar)

{
int numar = 0;
struct st_litera *curent; /* pointerul cu care se parcurge lista */
*pcar=start->car; /* se transmite prin adresa primita, caracterul cautat */
curent=start->urm;
while (curent != start) /* cat timp referinta la urmatorul din lista */
{ /* nu a ajuns la santinela/ start */
if (start->car == curent->car) /* se numara daca este caracterul */
numar++;
curent=curent->urm;
}
return (numar);
}
void main()
{
struct st_litera *primul;
char ch;
primul->urm=primul->pred=primul; /* lista vida */
printf("\nProgramul construieste si afiseaza o lista circulara de char.\n");
printf("Introduceti caractere (CTRL-Z, Enter-pentru sfarsit):\n");
atasare(primul);
printf("\nLista circulara construita este:\n");
afis_list_circ(primul);
printf("Caracterul de cautat in lista: ");
ch=getch();
primul->car=ch; /* se pune caracterul de cautat in santinela/ start */
printf("\nCaracterul \'%c\' este in lista de %d ori\n",
26
ch, numar_aparitii_car(primul, &ch));
}
/* listord.c - construiete o lista ordonata de numere intregi, distincte */

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct st_numar {
int numar;
struct st_numar *next;
};
int nvl=0; /* numarul de valori afisate pe linie */
void main()
{
struct st_numar *inserare (struct st_numar *, int );
struct st_numar *prim, *vr;
int nr;
clrscr();
printf("Programul construieste o lista ordonata, de numere distincte.\n");
printf("Introducerea numerelor se termina cu o valoare nenumerica.\n");
printf("Numar de inserat in lista: ");
prim=(struct st_numar *) malloc(sizeof (struct st_numar));
scanf("%d", &prim->numar); /* citire numar de introdus in lista */
prim->next=NULL;
while (scanf("%d", &nr)==1){
prim=inserare (prim, nr);
}
/* tiparirea listei introduse cu eliberarea memoriei alocate */
printf("\nLista de numere ordonata este:\n");
while (prim)
{vr=prim; /* variabila auxiliara pentru a apela functia free() */
printf("%d -> ", vr->numar);
nvl++;
if (nvl%8==0) /* daca s-au tiparit 8 valori pe linie */
printf("\n"); /* se trece pe o linie noua */
prim=prim->next;
free(vr); /* eliberare memorie alocata pentru vr */
}
printf("NULL\n"); /* tiparire sfarsit de lista */
}
27
struct st_numar *inserare (struct st_numar *primul, int n){
/* daca nu se mai poate aloca memorie se rutrneaza poiterul NULL,
altfel se returneaza pointerul la primul numar din lista,
care se poate modifica daca se insereaza un numar mai mic
decat primul din lista */
struct st_numar *anterior, *curent, *vr;
vr=(struct st_numar *) malloc(sizeof(struct st_numar));
if (vr == NULL){
printf("\nNu mai introduceti numere!!!\nMEMORIE PLINA!!!\n");
return (primul);
}
else
{
vr->numar=n;
anterior=NULL; /* initializare pointeri 'anterior' si 'curent' */
curent=primul; /* pentru det. pozitie element de inserat, vr */
while (curent != NULL && vr->numar > curent->numar)
{
anterior=curent;
curent=curent->next;
} /* vr trebuie inserat intre anterior si curent */
if(vr->numar == curent->numar) /* daca numarul exista in lista */
{free(vr); /* elibereaza spatiul alocat variabilei 'vr' */
return (primul); /* nu mai insereaza si termina inserarea */
}
vr->next=curent;
if (anterior == NULL) /* se insereaza in fata primului din lista */
primul=vr; /* este pus primul in lista */
else
anterior->next=vr; /* este pus dupa 'anterior' */
return (primul);
}
}
/* listrec1.cpp - programul construieste o lista de cuvinte, introduse
de la tastatura, pe care apoi le afiseaza, utilizand functii recursive:
atsare - pentru construire lista, si
afisare - pentru afisare lista;
Varianta 2: elementul din lista contine adresa cuvantului citit,
pentru care se aloca spatiu (strdup) la citire;
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
28
#define SIR_VID ""
#define DIMC 25
int nvl=0;
struct st_cuvant
{
};
int atasare (struct st_cuvant * vr)
{ /* citeste un cuvant, creaza o variabila dinamica vr si o ataseaza
la lista */
char cuv[DIMC], *pc;
if (vr->urmator==NULL) /* daca referinta este NULL se ceaza un pointer */
{
vr->urmator=(struct st_cuvant *)malloc(sizeof(struct st_cuvant));
if (vr->urmator==NULL)
return (0);
else
{
gets(cuv);
if (!strcmp(cuv,SIR_VID))
{vr->urmator=NULL;
return(0);
}
else
{if(!(pc=strdup(cuv)))
{vr->urmator=NULL;
return(0);
}
else
{
vr=vr->urmator;
vr->urmator = NULL;
vr->cuvant=pc;
return (1);
}
}
}
}
else /* daca s-a putut crea un pointer se continua atasarea */
return(atasare (vr->urmator));
}
void afisare (struct st_cuvant * curent)
29
{
if (curent)
{
printf ("%s -> ", curent -> cuvant);
nvl++;
if(nvl%5==0)
printf("\n");
afisare (curent -> urmator);
}
}
void main()
{
struct st_cuvant *primul;
char c[DIMC];
clrscr();
" tastatura\n");
gets(c);
primul->cuvant=strdup(c);
while (atasare(primul));
afisare (primul);
printf("NULL\n");
}
/* listrecc.cpp - programul construieste o lista de cuvinte,

introduse de la tastatura, pe care apoi le afiseaza,
utilizand functii recursive:
atsare - pentru construire lista, si
afisare - pentru afisare lista;
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMC 20
int nvl=0;
struct st_cuvant
{
char cuvant[DIMC]; /* sirul de caractere (cuvant) */
30
};
int atasare (struct st_cuvant * vr)
{ /* citeste un cuvant, creaza o variabila dinamica vr si o
ataseaza la lista */
char cuvcit[DIMC];
if (vr->urmator==NULL) /* daca referinta este NULL se ceaza un pointer */
{
vr->urmator=(struct st_cuvant *)malloc(sizeof(struct st_cuvant));
if (vr->urmator==NULL)
return (0);
else
{gets(cuvcit);
if (!strcmp(cuvcit,SIR_VID))
{vr->urmator=NULL;
return(0);
}
else {
vr=vr->urmator;
vr->urmator=NULL;
strcpy(vr->cuvant, cuvcit);
return (1);
}
}
}
else /* daca s-a putut crea un pointer se continua atasarea */
return(atasare (vr->urmator));
}
void afisare (struct st_cuvant * curent)

{
if (curent)
{
printf ("%s -> ", curent -> cuvant);
nvl++;
if(nvl%5==0)
printf("\n");
afisare (curent -> urmator);
}
}
void main()
{
struct st_cuvant *primul;
31
clrscr();
primul=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
printf("Programul construieste o lista de tip coada cu cuvinte "
"de la tastatura\n");
gets(primul->cuvant);
while (atasare(primul));
afisare (primul);
printf("NULL\n");
}
/* stivacar.c - programul construieste o stiva de caractere, pe care apoi o tipareste */

#include <stdio.h>
struct st_lista
{
char car;
struct st_lista *urmator;
};
void main()
{
struct st_lista *vr, *primul;
char c;
primul = NULL;
printf("\nProgramul construieste si afiseaza o stiva de caractere.\n");
fflush(stdin);
if (c!='\n')
{vr=(struct st_lista *) malloc(sizeof(struct st_lista));
if (vr == NULL)
{ /* daca pointerul returnat de functia malloc() este
NULL */
printf("Memorie plina !!!!!!\n"); /* se tipareste un
mesaj de eroare */
caractere */
}
vr->car=c;
vr->urmator=primul;
primul=vr;
}
vr=primul; /* initializare pointer curent, vr, pentru a referi
32
primul caracter */
while (vr != NULL)
{
printf("%c -> ", vr->car);
vr=vr->urmator;
}
printf(" NULL");/* tiparire sfarsit lista caractere sau lista vida daca
primul era NULL */
}
/* stivatab.c - operatii cu o stiva realizata static intr-un tablou;

operatii disponibile: inserare, extragere, afisare cap stiva,
afisare stiva, afisare pointer la varful stivei */
#include <stdio.h>
#include <conio.h>
#define MaxS 10
typedef int ElTip; // ElTip - definire tip element din stiva

typedef struct {
ElTip elem [MaxS];// spatiu pentru elem. stivei
int sp;
/* index/ referinta la varful stivei (stack pointer) */
} TStiva, *AStiva;

}
void InitStiva (AStiva rs){

/* initializare stiva, sp nu refera un element (stiva goala) */
rs->sp=-1;
}
int StivaGoala (AStiva rs){

return (rs->sp == -1);
}
int StivaPlina (AStiva rs){

/* stiva este plina, index=MaxS-1, indice maxim,
nu se mai pot introduce elemente in stiva */
return (rs->sp == MaxS-1);
}
void Push (AStiva rs, ElTip el){
33
/* introduce element in stiva, daca nu este plina */
if (StivaPlina (rs))
eroare ("Stiva Plina !!!");
else {rs->sp=rs->sp+1;
rs->elem[rs->sp]=el;
}
}
ElTip Pop (AStiva rs){

/* extrage element din stiva, daca nu este goala */
ElTip e;
if (StivaGoala (rs))
{eroare ("Stiva Goala !!!");
return 0;
}
else
{e=rs->elem[rs->sp];
rs->sp=rs->sp-1;
return e;
}
}
ElTip CapStiva (AStiva rs){

return 0;
}
else
return rs->elem[rs->sp];
}
void AfisareStiva (AStiva rs){

/* se creaza o copie a stivei curente, pentru a utiliza functiile
definite pentru operare stiva (Pop, CapStiva, StivaGoala) */
TStiva s=*rs;
AStiva pt=&s;
if (pt->sp == -1)
eroare("Stiva Goala !!!\n");
else
while (!StivaGoala (pt))
{printf ("%d -> ", CapStiva (pt));
Pop (pt);
if (++nvl % 10 == 0)
34
printf("\n");
}
printf("NULL\n");
}
void Afisare_Poz_sp (AStiva rs){

printf("Referinta (indexul), sp: %d\n", rs->sp);
if (!rs->sp)
printf("\tSTIVA GOALA!!!\n");
else if (rs->sp == MaxS-1)
printf("\tSTIVA PLINA !!! ELIMINATI ...\n");
}
void main (void){

TStiva s, *rs;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de stiva realizata utilizand un tablou.\n");
printf("Stiva este alcatuita din numere intregi.\n");
InitStiva (rs);
printf("\nOptiuni Introduc, Extrag, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
switch(optiune[0]){
case 'i':
case 'I':if (StivaPlina(rs)){
eroare("\n\tSTIVA PLINA !!! ELIMINATI...\n");
break;}
while (scanf("%d", &n) == 1 && !StivaPlina(rs)){
Push (rs, n);
if (StivaPlina (rs)){
eroare("Stiva PLINA !!! ELIMINATI.....\n");
break;
}
}
fflush(stdin);
break;
case 'e':
while ( !StivaGoala (rs) &&
35
{printf ("Se extrage primul element din stiva: %d\n",
CapStiva (rs));
Pop (rs);
if (!StivaGoala (rs)){
gets(optiune);
fflush(stdin);
}
}
printf("Stiva Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!StivaGoala (rs))
printf("Afisare element din capul stivei: %d\n",
CapStiva (rs));
else
break;
case 'a':
case 'A':AfisareStiva (rs);
break;
case 'p':
case 'P': Afisare_Poz_sp (rs);
break;
}
printf("\nOptiuni Int, Ext, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
}
}
/* stivatbv.c - operatii cu o stiva realizata static intr-un tablou;

operatii disponibile: inserare, extragere, afisare cap stiva,
afisare stiva, afisare pointer la varful stivei
Varianta: functia de afisare AfisareStivaV (rs), nu mai creaza o copie
a stivei, si deci nu mai utilizeaza functiile stivei, ci un index local */
#include <stdio.h>
#include <conio.h>
#define MaxS 10
typedef int ElTip; // ElTip - definire tip element din stiva

typedef struct {
ElTip elem [MaxS];// spatiu pentru elem. stivei
int sp;
36
/* index/ referinta la varful stivei (stack pointer) */
} TStiva, *AStiva;

}
void InitStiva (AStiva rs){

/* initializare stiva, sp nu refera un element (stiva goala) */
rs->sp=-1;
}
int StivaGoala (AStiva rs){

return (rs->sp == -1);
}
int StivaPlina (AStiva rs){

/* stiva este plina, index=MaxS-1, indice maxim,
nu se mai pot introduce elemente in stiva */
return (rs->sp == MaxS-1);
}
void Push (AStiva rs, ElTip el){

/* introduce element in stiva, daca nu este plina */
if (StivaPlina (rs))
eroare ("Stiva Plina !!!");
else {rs->sp=rs->sp+1;
rs->elem[rs->sp]=el;
}
}
ElTip Pop (AStiva rs){

/* extrage element din stiva, daca nu este goala */
ElTip e;
return 0;
}
else
{e=rs->elem[rs->sp];
rs->sp=rs->sp-1;
return e;
}
}
37
ElTip CapStiva (AStiva rs){
return 0;
}
else
return rs->elem[rs->sp];
}
void AfisareStivaV (AStiva rs){

/* se utilizeaza un pointer local pentru a afisa valorile din stiva */
int psl=rs->sp;
if (rs->sp == -1)
else
while (psl != -1)
{printf ("%d -> ", rs->elem[psl]);
psl--;
if (++nvl % 10 == 0)
printf("\n");
}
printf("NULL\n");
}
void Afisare_Poz_sp (AStiva rs){

printf("Referinta (indexul), sp: %d\n", rs->sp);
if (!rs->sp)
printf("\tSTIVA GOALA!!!\n");
else if (rs->sp == MaxS-1)
printf("\tSTIVA PLINA !!! ELIMINATI ...\n");
}
void main (void){

TStiva s, *rs;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de stiva realizata utilizand un tablou.\n");
printf("Stiva este alcatuita din numere intregi.\n");
InitStiva (rs);
printf("\nOptiuni Introduc, Extrag, Afis stiva, Cap stiva, Poz sp Stop: ");
gets(optiune);
38
switch(optiune[0]){
case 'i':
case 'I':if (StivaPlina(rs)){
eroare("\n\tSTIVA PLINA !!! ELIMINATI...\n");
break;}
while (scanf("%d", &n) == 1 && !StivaPlina(rs)){
Push (rs, n);
if (StivaPlina (rs)){
eroare("Stiva PLINA !!! ELIMINATI.....\n");
break;
}
}
fflush(stdin);
break;
case 'e':
while ( !StivaGoala (rs) &&
{printf ("Se extrage primul element din stiva: %d\n",
CapStiva (rs));
Pop (rs);
if (!StivaGoala (rs)){
gets(optiune);
fflush(stdin);
}
}
printf("Stiva Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!StivaGoala (rs))
printf("Afisare element din capul stivei: %d\n",
CapStiva (rs));
else
break;
case 'a':
case 'A':AfisareStivaV (rs);
break;
case 'p':
39
case 'P': Afisare_Poz_sp (rs);
break;
}
printf("\nOptiuni Int, Ext, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
}
}
/* stivcdif.c - programul construieste o stiva de caractere distincte, pe care apoi o tipareste */

#include <stdio.h>
struct st_lista
{
char car;
struct st_lista *urmator;
};
void main()
{
struct st_lista *vr, *primul;
char c;
int distinct (struct st_lista *prim, char ch);
primul = NULL;
printf("\nProgramul construieste si afiseaza o stiva de caractere.\n");
fflush(stdin);
if (c != '\n' && (distinct(primul, c)))
{
vr=(struct st_lista *) malloc(sizeof(struct st_lista));
if (vr == NULL)
{ /* daca pointerul returnat de functia
malloc() este NULL */
printf("Memorie plina !!!!!!\n"); /* mesaj de
eroare */
caractere */
}
vr->car=c;
vr->urmator=primul;
primul=vr;
}
vr=primul; /* initializare pointer curent, vr, pentru a referi
primul caracter */
while (vr != NULL)
{
40
printf("%c -> ", vr->car);
vr=vr->urmator;
}
printf(" NULL");/* tiparire sfarsit lista caractere sau lista vida daca
primul era NULL */
}
int distinct (struct st_lista *prim, char ch)
{
struct st_lista *ptr;
int gasit;
ptr=prim; /* initializare pointer curent cu primul din lista */
gasit=0; /* presupunem ca nu l-am gasit inca */
while (ptr != NULL && !gasit) /* cat timp nu s-a terminat lista si nu
l-am gasit */
{ /* se continua parcurgerea listei */
gasit=(ptr->car == ch);
ptr=ptr->urmator;
}
return (!gasit);
}
/* HeapSMax.c - Ord. descresc., prin selectie Heapsort:
construim Heap-ul, arborele de selectie, memorat intr-un
vector, dupa care se interschmba prima valoare (maximul)
cu ultima si in vectorul ramas (n-1) se construieste
din nou Heap-ul, s.a.m.d.
*/
#include<stdio.h>
#include <conio.h>
void cerne (double a[], int l, int r)
{
int i,j;
double x;
i=l; j=2*i; x=a[i]; /* x ce se cerne prin arbore/ vector */
while (j<=r){
if (j<r) /* nu s-a ajuns la capat */
if (a[j]<a[j+1]) /* j-ind. val. mai mare din */
j++; /* perechea (2*i, 2*i + 1) */
if (x>a[j]) /* daca x > valoarea respectiva (j) */
goto gata; /* altfel, se muta */
a[i]=a[j]; /* valoarea mai mare a[j] la a[i], si se */
i=j; j=2*i; /* continua cernerea pe nivelul urmator */
} /* noul i devine j (vechi i), iar j=2i, daca j<r */
gata: a[i]=x; /* pune x in poz. i, a[i]<a[2i], a[i]<a[2i+1] */
}
41
void heapsort(double a[], int n){
int i, l, r;
double x;
l=(n/2)+1; r=n;
while (l>1){
l--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
printf (" %0.lf ", a[i]);
if (i%10==0)
printf("\n");
}
printf("\nApasa o tasta pentru continuare program!\n");
getch();
}
while(r>1)
{x=a[1];
a[1]=a[r];
a[r]=x;
r--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
if (i%10==0)
printf("\n");
}
getch();
}
}
void main(void)
{
double sir[1000];
int ne, i;
clrscr();
printf("HeapSort pentru ordonare crescatoare vector.\n");
printf ("Numarul de elemente: ");
scanf ("%d",&ne);
for ( i = 1 ; i <= ne ; ++i)
{
printf (" sir(%d)=", i);
scanf ("%lf", &sir[i]);
42
}
heapsort(sir,ne);
for( i = 1 ; i <= ne ; ++i ){
printf (" %0.lf ", sir[i]);
if (i%10==0)
printf("\n");
}
printf("\nPROGRAM TERMINAT! Apasa o tasta-iesire!!!\n");
getch();
}
/* HeapSmin.c - Ord. descresc., prin selectie Heapsort:

construim Heap-ul, arborele de selectie, memorat intr-un
vector, dupa care se interschmba prima valoare (minimul)
cu ultima si in vectorul ramas (n-1) se construieste
din nou Heap-ul, s.a.m.d.
*/
#include<stdio.h>
#include <conio.h>
void cerne (double a[], int l, int r)
{
int i,j;
double x;
i=l; j=2*i; x=a[i]; /* x ce se cerne prin arbore/ vector */
while (j<=r){
if (j<r) /* nu s-a ajuns la capat */
if (a[j]>a[j+1]) /* j-ind. val. mai mica din */
j++; /* perechea (2*i, 2*i + 1) */
if (x<a[j]) /* daca x < valoarea respectiva (j) */
goto gata; /* altfel, se muta */
a[i]=a[j]; /* valoarea mai mica a[j] la a[i], si se */
i=j; j=2*i; /* continua cernerea pe nivelul urmator */
} /* noul i devine j (vechi i), iar j=2i, daca j<r */
gata: a[i]=x; /* pune x in poz. i, a[i]<a[2i], a[i]<a[2i+1] */
}
void heapsort(double a[], int n){

int i, l, r;
double x;
l=(n/2)+1; r=n;
while (l>1){
l--;
43
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
if (i%10==0)
printf("\n");
}
getch();
}
while(r>1)
{x=a[1];
a[1]=a[r];
a[r]=x;
r--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
if (i%10==0)
printf("\n");
}
getch();
}
}
void main(void)
{
double sir[1000];
int ne, i;
clrscr();
scanf ("%d",&ne);
for ( i = 1 ; i <= ne ; ++i)
{
printf (" sir(%d)=", i);
}
heapsort(sir,ne);
for( i = 1 ; i <= ne ; ++i ){
printf (" %0.lf ", sir[i]);
if (i%10==0)
printf("\n");
}
printf("\nPROGRAM TERMINAT! Apasa o tasta-iesire!!!\n");
44
getch();
}
/*
ins_bin.c - prog. de ordonare cresc. sir, utilizand metoda de inserare binara,
adica: se considera un sir ordonat, format initial din primul element din
sirul initial, si un sir neordonat, format din restul elementelor sirului,
din care se iau pe rand celelalte elemente si li se cauta, de la dreapta
la stanga, pozitia in sirul ordonat, construit tot in sirul initial.
Cautarea se face utilizand metoda "binara".
*/
#include<stdio.h>
#include <conio.h>
int ncomp=0, nins=0; /* numar de comparatii si inserari/deplasari */
/* functia de sortare prin inserare binara */

void sort_ins_binara ( double a[], int n )
{
double x;
int i, j, s, d, m;
for (i=1; i<n; ++i)
{
x=a[i]; s=0; d=i-1;/* initializari: x-elementul de inserat */
while (s <= d) /* s, d-limitele stanga/dreapta pentru subsir dest */
{ncomp++;
m=(s+d)/2; /* mijlocul subsirului */
if (x < a[m]) /* in functie de apartenenta elementului x */
d=m-1; /* la subsirul din stanga sau dreapta */
else /* se stabileste noua limita din stanga/dreapta */
s=m+1; /* a noului subsir, in care se cauta */
} /* dupa determinarea pozitiei de inserare a elem.*/
for (j=i-1; j>=s; --j, nins++) /* se deplaseaza tot sirul cu */
a[j+1]=a[j]; /* o pozitie la dreapta, de la pozitia */
a[s]=x; /* de inserare pana la sfarsit, dupa care */
/* se insereaza noul element, x */
}
}
void main(void){
double sir[100]; int ne,i;
clrscr();
printf("Numar elemente:");
scanf("%d", &ne);
for(i=0; i<ne; i++) /* citire sir de ordonat */
45
{
printf("sir(%d)= ", i+1);
scanf("%lf", &sir[i]);
}
printf("Sirul ordonat este: \n");
sort_ins_binara(sir , ne);/* apelul functiei de sortare binara */
for (i=0;i<ne;i++) /* afisare sir ordonat */
{
printf(" sir (%2d) = %lf \n", i+1, sir[i]);
if ((ne+1)%4==0) /* tiparesc cate 4 valori pe linie */
printf("\n");
}
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d deplasari\n",
ncomp, nins);
}
/* ins_dir.c- prog. ordonare cresc. sir, utilizand metoda de inserare directa, adica:
se considera un sir ordonat, format initial din primul element din sirul initial,
si un sir neordonat, format din restul elementelor sirului, din care se iau pe
rand celelalte elemente si li sa cauta, de la dreapta la stanga, pozitia in
sirul ordonat, construit tot in sirul initial. */
#include <stdio.h>
#include <conio.h>
int ncomp=0, nins=0; /* numar de comparatii si inserari/ deplasari */
void sort_ins_direct (double a[], int n)

{/* functia de sortare prin inserare directa */
double x;
int i, j;
for (i=1; i<n; ++i)
{
x=a[i]; /* elementul curent de inserat */
j=i-1; /* dimensiunea sirului destinatie */
while (x < a[j] && j >= 0)
{ /* se cauta pozitia de inserare */
a[j+1]=a[j];
j--;
ncomp++; nins++;
}
a[j+1]=x; /* inseare element curent */
}
}
46
void main()
{
double sir[100];
int ne, i;
clrscr();
scanf("%d", &ne);
for(i=0; i<ne; i++) /* citirea elementelor sirului de sortat */
{
printf("sir(%d)= ", i+1);
}
sort_ins_direct (sir, ne); /* ordonarea sirului prin inserare directa */
printf("\n Sirul ordonat:\n");
for(i=0; i<ne; i++) /* afisare sir ordonat */
{
printf(" sir(%d)=%5.2lf ", i+1, sir[i]);
if ( (i+1) %5 == 0 ) /* daca s-au afisat 5 valori din sir pe o linie */
}
printf("\n");
ncomp, nins);
/* MergeSor.c - Ordonare utilizand metoda MergeSort (interclasare) */

#include <stdio.h>
#include <conio.h>
#define DIM 20
void MergeSort (int v[], int p, int q){

int m, aux;
void Interclasare(int [], int, int, int);
if (q-p <= 1){
if (v[p]>v[q]){
aux=v[p];
v[p]=v[q];
v[q]=aux;
}
}
else{
m=(p+q)/2;
47
MergeSort(v, p, m);
MergeSort(v, m+1, q);
Interclasare(v, p, q, m);
}
}
void Interclasare (int v[], int p, int q, int m){

int i=p, j=m+1, k=0;
int *u=(int *) malloc (DIM * sizeof(int)); // alocare memorie pentru vect. u
while (i<=m && j<=q){
if (v[i] <= v[j]){
u[k]=v[i];
i++; k++;
}
else{
u[k]=v[j];
j++; k++;
}
}
if (i <= m)
for (j=i; j<=m; j++){
u[k]=v[j];
k++;
}
else
for (i=j; i<=q; i++){
u[k]=v[i];
k++;
}
k=0;
for (i=p; i<=q; i++){
v[i]=u[k];
k++;
}
free(u); // eliberarea spatiului alocat pentru vectorul u
}
void scrie_vector(int vect[], int d){

int i;
for (i=0; i<d; i++)
printf("%5d,", vect[i]);
}
void main()
48
{int vector[]={10, 5, 6, 12, 3, 7, 15, 12, 9, 4, 3};
int ne=11;
clrscr();
MergeSort(vector, 0, ne-1);
scrie_vector(vector, ne);
printf("\nApasati o tasta pentru a termina programul!\n");
getch();
}
/* QuickSit.c - sortarea unui vector utilizand algoritmul QuickSort, iterativ */

#include<stdio.h>
#include<conio.h>
#define DIM 100
typedef int VECTOR[DIM];

int ncomp=0, ninv=0; /* numar de comparatii, inversiuni */
void cit_vect(int n, VECTOR v)
{int i;
for(i=0; i<n; i++)
{printf("v[%d]=", i+1);
scanf("%d", &v[i]);}
}
void scrie_vect(int n, VECTOR v)

{int i;
for(i=0; i<n; i++)
printf("v[%d]=%d\n", i+1, v[i]);
}
void QuickSortit (VECTOR a, int n)

/* Sortara partajata (QuickSort) realizata iterativ */
{int s, d, i, j, is, x, t;
struct st_stiva {int s, d;}; /* element stiva: pozitia stanga, dreapta */
struct st_stiva stiva[DIM]; /* stiva ce contine lista de cereri partitie */
is=1; stiva[is].s=0; stiva[is].d=n-1; d=n-1; /* initializari */
do{
s=stiva[is].s; d=stiva[is].d; is--; /* partitia curenta de realizat*/
do {i=s; j=d; /* este luata din varful stivei */
x=a[(s+d)/2]; /* santinela */
do {
while (a[i]<x) i++, ncomp++;
while (a[j]>x) j--, ncomp++;
if (i<=j)
{t=a[i];
49
a[i]=a[j];
a[j]=t;
i++; j--;
ninv++;
}
} while(i<=j);
if (i<d){ /* depun in stiva cererea de a sorta */
is++; /* partitia dreapta */
stiva[is].s=i;
stiva[is].d=d;
}
d=j; /* se continua sortarea partitiei stanga, (s, d) */
} while (s<d); /* pana are un singur element (s==d) */
}while (is>0); /* se reia sortarea pentru partitiile stanga */
} /* ramase nerezolvate, in stiva */
void main(void)
{int n;
VECTOR v;
clrscr();
printf("Programul ordoneaza (sorteaza) un vector cu alg. QuickSort.\n");
printf("Dimensiune vector, n=");scanf("%d", &n);
cit_vect(n, v);
QuickSortit (v, n);
printf("\nVectorul ordonat este:\n");
scrie_vect(n, v);
printf("Sortarea s-a realizat dupa %d comparatii si %d inversiuni\n",
ncomp, ninv);
getch();
}
/* QuickSor.c - sortarea unui vector utilizand algoritmul QuickSort */

#include<stdio.h>
#include<conio.h>
#define DIM 100
typedef int VECTOR[DIM];

{int i;
for(i=0; i<n; i++)
{printf("v[%d]=", i+1);
}
50
{int i;
for(i=0; i<n; i++)
}
void QuickSort(VECTOR a, int s, int d)

{int i, j, m, x, temp;
i=s;
j=d;
m=(s+d)/2;
x=a[m];
do
{while (a[i]<x) i++, ncomp++;
while (a[j]>x) j--, ncomp++;
if (i<=j)
{temp=a[i];
a[i]=a[j];
a[j]=temp;
i++;
j--;
ninv++;
}
}while(i<=j);
if(s < j) QuickSort(a, s, j);
if(i < d) QuickSort(a, i, d);
}
void main(void)
{int n;
VECTOR v;
clrscr();
printf("Programul ordoneaza (sorteaza) un vector cu alg. QuickSort.\n");
printf("Dimensiune vector, n=");scanf("%d", &n);
cit_vect(n, v);
QuickSort(v, 0, n-1);
scrie_vect(n, v);
printf("Sortarea s-a realizat dupa %d comparatii si %d inversiuni\n",
ncomp, ninv);
getch();
}
51
/* sel_dir.c - programul ordoneaza un vector prin selectie directa,
utilizand pentru aceasta determinarea minimului si a pozitiei lui,
la fiecare iteratie si realizand o singura inversiune intre acest
minim si valoarea a[i], corespunzatoare iteratiei curente;
se determina si numarul de comparatii si inversiuni realizate
*/
#include<stdio.h>
#include <conio.h>
int ncomp=0, ninv=0; /* numar de comparatii si inversiuni */
void sort_sel_direct ( double a[], int n )
/* functia sorteaza un vector prin metoda de selectie directa */
{
double x;
int i, j, k;
for ( i = 0 ; i < n-1 ; ++i )
{
k = i; /* initializare indice, k, si elementul minim, x */
x = a[i];
for ( j = i+1 ; j < n ; ++j, ncomp++ ) /* determinare minim si indicele lui din sir */
if (a[j] < x)
{
k = j;
x = a[k];
}
a[k] = a[i]; /* interschimbare minim cu primul din subsirul sursa, */
a[i] = x; /* adica cu primul din subsirul neordonat */
ninv++;
}
}
void main()
{
double sir[100];
int ne,i, nl=0;
clrscr();
scanf("%d",&ne);
for(i=0;i<ne;i++) /* citirea elementelor sirului de ordonat */
{
printf("sir(%d)=",i+1);
scanf("%lf",& sir[i]);
}
sort_sel_direct(sir,ne); /* ordonarea sirului prin selectie directa */
for(i=0;i<ne;i++) /* afisarea sirului ordonat */
{
52
printf(" sir(%2d)=%5.1lf",i+1,sir[i]);
nl++; /* actualizare contor numar de valori afisate pe o linie */
if ( nl % 5 == 0 ) /* daca s-au afisat 5 valori pe o linie se trece pe */
printf("\n"); /* o linie noua */
}
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d inversiuni\n",
ncomp, ninv);
}
/* sel_dirv.c - Program de ordonare crescatoare sir, utilizand

metoda de selectie directa, adica: din sirul initial se pune
valoarea minima pe prima pozitie, apoi pentru subsirul ramas,
[2,n], se pune valoarea minima pe pozitia 2, s.a.m.d,
prin interschimbari multiple; pentru fiecare valoare, sir[i],
ori de cate ori se determina o valoare sir[j]<sir[i],
se inverseaza cele doua valori (se determina si numarul
de comparatii si inversiuni realizate pentru ordonare)
*/
#include<stdio.h>
#include <conio.h>
void sort_sel_dir (double sir[], int nrelem)
{ /* selectie directa prin interschimbari, pentru fiecare
valoare mai mica decat iteratia curenta, i, sir[i]. */
int i, j;
double aux;
for( i = 0; i < nrelem-1; ++i)
for( j = i+1; j < nrelem ; ++j, ncomp++){
if ( sir[i] > sir[j] )
{
aux = sir[i];
sir[i] = sir[j];
sir[j] = aux;
ninv++;
}
}
}
void main(void)
{
double sir[1000];
int ne, i;
clrscr();
53
scanf ("%d",&ne);
for ( i = 0 ; i < ne ; ++i)
{
printf (" sir(%2d)=", i+1);
}
sort_sel_dir(sir,ne);
for( i = 0 ; i < ne ; ++i ){
printf (" sir(%2d)=%5.2lf ", i+1, sir[i]);
if ((i+1)%4==0)
printf("\n");
}
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d inversiuni\n",
ncomp, ninv);
}
/* shaker.cpp - ordonare (sortare) vector utilizand metoda "ShakerSort"

*/
#include<stdio.h>
#include<conio.h>
typedef int VECTOR[30];
int ncomp=0, ninv=0; /* numar de comparatii si inversiuni/ deplasari */
{int i;
for(i=0; i<n; i++)
{printf("v[%d]=", i+1);
}

{int i;
for(i=0; i<n; i++)
}
void shaker(int n, VECTOR v)
{int t, i, k, s, d;
d=n-2; s=0; k=d; /* initializari pentru limita din stanga (s), dreapta (d) */
do /* iar k reprezinta pozitia la care s-a realizat ultima inversiune */
/* ncomp, ninv - numar de comparatii, inversiuni realizate */
{for (i=s; i<=d; i++, ncomp++) /* parcurg de la stanga la dreapta */
if (v[i] > v[i+1])/* daca este cazul se inverseaza */
{t=v[i];
v[i]=v[i+1];
54
v[i+1]=t;
k=i; /* se retine pozitia ultimei inversiuni */
ninv++;}
d=k-1; /* se modifica corespunzator limita din dreapta */
for (i=d; i>=s; i--, ncomp++) /* parcurg de la dreapta la stanga */
if (v[i+1] < v[i]) /* daca este cazul se invers. elem. */
{t=v[i];
v[i]=v[i+1];
v[i+1]=t;
k=i; /* se retine pozitia ultimei inversiuni */
ninv++;}
s=k+1; /* se modifica corespunzator limita din stanga */
}while(s <= d);
}
void main(void)
{int n;
VECTOR v;
clrscr();
printf("\nProgramul ordoneaza (sorteaza) un vector, metoda \"Shaker\".\n");
printf("\tDimensiune vector, n= ");scanf("%d",&n);
cit_vect(n,v);
shaker(n,v);
printf("\nSirul ordonat este:\n");
scrie_vect(n,v);
ncomp, ninv);
printf("\n\tApasati o tasta pentru a termina programul\n");
getch();
}
/* sortbule.c - programul ordoneaza un sir de valori prin

metoda inversiunilor (bulelor) - forma clasica
*/
#include <stdio.h>
#include <conio.h>
int ncomp=0, ninv=0; /* numar de comparatii si inversiuni/ deplasari */
void sort_met_bulelor (double a[], int n)

/* functia sorteaza un vector prin metoda inversiunilor (bulelor) */
{double x;
int i, j;
for (i=1; i<n; i++)
for (j=n-1; j>=i; j--, ncomp++)
55
if (a[j-1] > a[j])
{
x=a[j-1];
a[j-1]=a[j];
a[j]=x;
ninv++;
}
}
void main(){
double sir[100];
int ne,i, nl=0;
clrscr();
scanf("%d", &ne);
for(i=0; i<ne; i++) /* citirea elementelor sirului de ordonat */
{printf("sir(%d)=",i+1);
}
sort_met_bulelor (sir, ne); /* ordonarea sirului prin selectie directa */
for(i=0; i<ne; i++) /* afisarea sirului ordonat */
{
printf("sir(%2d)=%5.1lf ", i+1, sir[i]);
nl++; /* actualizare contor numar de valori afisate pe o linie */
if (nl % 5 == 0) /* daca s-au afisat 5 valori pe o linie */
}
printf("\n");
ncomp, ninv);
}
/* sortindx.c - se sorteaza indecsii unui tablou de tip structura,

care contine date pentru un numar de studenti (nume, prenume si media)
asociat acestui tablou definim un tablou cu indecsii tabloului de studenti;
vom sorta studentii dupa medii prin intermediul tabloului de indecsi,
iar sortarea indicilor se va face utiliznd algoritmul ShakerSort
*/
#include <stdio.h>
#define DIM 100
#include <conio.h>
struct tip_struct
{
56
char nume_prenum [DIM];/* numele si prenumele unui student*/
float medie;
};
void main(void)
{
struct tip_struct stud [100];/* consideram un tablou de studenti */
int ind[100]; /* vectorul ce contine indecsii tabloului initial, si ce
va fi ordonat in functie de valorile vectorului de ordonat "tab" */
int i, ns;
float f;
void ShakerSort (struct tip_struct tab[], int index[], int n);
clrscr();
printf("Numarul de studenti:");
scanf("%d", &ns);
f=0.0; fflush(stdin);
for (i=0; i<ns; i++) /* citire date studenti: nume, prenume si media */
{
printf("Numele si prenumele studentului %d: ", i+1);
gets(stud[i].nume_prenum);
printf("Media notelor sale: ");
scanf("%f", &f);
stud[i].medie=f;
while (getchar() != '\n');
}
for (i=0; i<ns; i++) /* initializarea tabloului de indici */
ind[i] = i;
ShakerSort (stud, ind, ns); /* sortarea vectorului */
printf("Lista ordonata cu numele / prenumele si media studentilor\n");
for (i=0; i<ns; i++)
printf("%s %.2f\n", stud[ind[i]].nume_prenum,
stud[ind[i]].medie);
}
void ShakerSort (struct tip_struct tab[], int index[], int n)

{
int i, s, d, k, t;
d=n-2; s=0; k=d;
do {
for (i=s; i<=d; i++)
if (tab[index[i]].medie < tab[index[i+1]].medie)
{
t=index[i];
index[i]=index[i+1];
57
index[i+1]=t;
k=i;
}
d=k-1;
for (i=d; i>=s; i--)
if (tab[index[i+1]].medie > tab[index[i]].medie)
{
t=index[i];
index[i]=index[i+1];
index[i+1]=t;
k=i;
}
s=k+1;
} while (s <= d);
}
/* SortShel .c - programul ordoneaza un vector cu metoda Shell */

#include <stdio.h>
#include <conio.h>
#define N_MAX 100
typedef double VECTOR [N_MAX];

void Sort_Shell (VECTOR v, int dim){

int i, pas, inv;
double a;
pas = dim;
while (pas >1 )
{
pas=pas/2 ;
do
{
inv=0 ; /* fals */
for (i=0; i < dim-pas; i++)
{ncomp++;
if (v[i] > v[i+pas])
{
a=v[i+pas];
v[i+pas]=v[i];
v[i]=a;
inv=1;
ninv++;
}
58
}
} while (inv);
}
}
void main (void)

{
VECTOR sir, a;
int n, i, j , inv ;
clrscr();
printf ("Numarul de elemente ale sirului (<=100): " ) ;
scanf ("%d", &n) ;
for (i=0; i<n; ++i)
{
printf ("sir[%2d]= ", i+1);
scanf ("%lf", &sir[i]) ;
}
Sort_Shell(sir, n);
for (i=0; i<n; ++i){
printf ("sir[%2d]=%5.2lf ", i+1, sir[i]);
if ((i+1)%4==0)
printf("\n");
}
printf("\nSortarea s-a realizat dupa %d comparatii si %d inversiuni\n",
ncomp, ninv);
getch();
}
/* comisvoj.c - problema comis-voiajorului, utilizand metoda Greedy

*/
#include <stdio.h>
#include <conio.h>
#define DIM_MAX 6
void main()
{
int dist[DIM_MAX][DIM_MAX], muchie_sel[DIM_MAX];
int n, i, j, isel=0, nsel=0, distmin;
clrscr();
printf("Numarul total de orase de parcurs de comis-voiajor: ");
scanf("%d", &n);
printf("Specificati pentru ruta distanta:\n");
for(i=0; i<n-1; i++){ /* citirea distantelor dintre orase */
for (j=i+1; j<n; j++)
59
{
printf("Distanta (%d, %d)= ", i+1, j+1);
scanf("%d", &dist[i][j]);
dist[j][i]=dist[i][j];
}
muchie_sel[i]=0;
}
do {i=0;
while (muchie_sel[i] || i==isel)
i++;
distmin=dist[isel][i];
}while (nsel!=n);
getch();
}
// ieslabir.c - problema "labirintului": iesirea dintr-un labirint

// specificat printr-o matrice L, in care se memoreaza valorile zecimale
// ale codificarilor binare ale drumului spre iesire, si anume:
// fiecare directie care duce spre iesire e codificata cu 1, iar
// restul cu 0; deci pentru o casuta oarecare se considera directiile:
// sus, dreapta, jos si stanga, in aceasta ordine; de exemplu daca o
// camera va avea directii spre iesire sus si stanga, adica 1001, in
// binar, se va memora valoarea 9; matricea va fi completata cu 2
// linii si 2 coloane care vor contine valorile 16 (iesire din labirint)
// Drumul spre iesire va fi memorat in matricea d[2][n*m], pe prima linie
// i, iar pe cea de-a doua j, pentru drumul catre iesire din pozitia k.
#include <stdio.h>
#include <conio.h>
#define N 10
#define M 15
#define DIM (N-1)*(M-1)
// N, M - dimensiuni matrice labirint, 2 linii si 2 coloane atasate;

// pentru a delimita labirintul
int L[N][M] = {{16, 16, 16, 16, 16, 16, 16},

{ 16, 0, 2, 1, 1, 0, 16},
{ 16, 0, 2, 0, 8, 0, 16},
{ 16, 0, 2, 4, 8, 0, 16},
{ 16, 1, 7, 4, 2, 0, 16},
{ 16, 0, 2, 0, 2, 0, 16},
{ 16, 16, 16, 16, 16, 16, 16},
60
};
int d[2][DIM];
int i, j, n=5, m=5, nr_sol=0, nse=4;
void tiparire (int k, int d[2][DIM])

{int h;
nr_sol++; // contorizare numar de solutii
printf("\nSolutia %d:\n", nr_sol);
for (h=1; h<=k; h++){
printf("[%d,%d]-> ", d[0][h], d[1][h]);
if (h%8==0)
printf("\n");
}
printf("\n");
if (nr_sol % nse == 0) // continua afisarea urmatorului ecran de solutii
{printf("\n"); // dupa afisarea a 'nse' solutii, apasa tasta 'Enter'
printf("Apasati ENTER pentru a continua afisarea");
getch();
clrscr();
}
}
void iesire (int k, int i, int j, int L[N][M], int d[2][DIM]){

int gasit, h;
if (L[i][j] == 16)
tiparire(k, d);
else
{k++;
d[0][k]=i;
d[1][k]=j;
gasit=0;
for (h=1; h<=k-1; h++)
if (d[0][h] == d[0][k] && d[1][h] == d[1][k])
gasit=1;
if (!gasit)
for (h=1; h<=4; h++)
switch (h){
case 1: if (L[i][j] & 8)
iesire(k, i-1, j, L, d);
break;
case 2: if (L[i][j] & 4)
iesire(k, i, j+1, L, d);
break;
case 3: if (L[i][j] & 2)
61
iesire(k, i+1, j, L, d);
break;
case 4: if (L[i][j] & 1)
iesire(k, i, j-1, L, d);
}
k--;
}
}
void main (void) {

int il, ic;
clrscr();
/*
printf("Dimensiuni labirint (matrice), linii, coloane: ");
scanf("%d%d", &n, &m);
for (il=1; il<=n; il++)
for (ic=1; ic<=m; ic++){
printf("L[%d, %d]=", il, ic);
scanf("%d", &L[il][ic])
}
*/
printf("Punctul de plecare din labirint (i, j): ");
scanf("%d%d", &i, &j);
// matricea L, impreuna cu cele 2 linii si 2 coloane, care
// delimiteaza labirintul, si specifica iesirea din labirint
// are dimensiunile (n+2)*(m+2)
L[0][ic]=16;
L[n+1][ic]=16;
}
for (il=1; il<=m; il++){
L[il][0]=16;
L[il][m+1]=16;
}
printf("\nLabirintul are urmatoarea configuratie:\n\n");
for (il=0; il<n+2; il++){
for (ic=0; ic<m+2; ic++)
if (il==i && ic==j)
printf(" x");
else
printf("%3d", L[il][ic]);
printf("\n\n");
}
printf("Coordonate punct plecare L[%d,%d]=%d\n", i, j, L[i][j]);
62
iesire(0, i, j, L, d);
printf("\nNumar total de solutii: %i\n", nr_sol);
printf("Apasati ENTER pentru a termina programul !");
getch();
}
// obiectpo.c - problema "fotografiei": determina numarul de obiecte
// dintr-o fotografie. Obiectele din fotografie sunt codificate cu 1,
// iar celelalte sunt 0. Pornind de la prima unitate determinata
// se cauta unitati adiacente pe cele 8 directii, care sunt puse pe 0
// eliminandu-se astfel obiectul identificat.
// Functia main() reapeleaza functia "obiect" pentru unitatile ramase
#include <stdio.h>
#include <conio.h>
#define N 10
#define M 15
// N, M - dimensiuni matrice fotografie, cu 2 linii si 2 coloane atasate;

// pentru a delimita fotografia
int F[N][M] = {{0, 0, 0, 0, 0, 0, 0},

{ 0, 1, 0, 1, 0, 1, 0},
{ 0, 0, 0, 0, 0, 0, 0},
{ 0, 1, 0, 0, 1, 0, 0},
{ 0, 0, 1, 0, 0, 1, 0},
{ 0, 0, 1, 1, 0, 1, 0},
{ 0, 0, 0, 0, 0, 0, 0},
};
int i, j, n=5, m=5;
void obiect (int i, int j, int F[N][M]){

if (F[i][j]==1){
F[i][j]=0; // sterg 1 al obiectului curent
obiect(i-1, j, F);
obiect(i-1, j+1, F);
obiect(i, j+1, F);
obiect(i+1, j+1, F);
obiect(i+1, j, F);
obiect(i+1, j-1, F);
obiect(i, j-1, F);
obiect(i-1, j-1, F);
}
}
63
void main (void) {
int il, ic, nr_ob=0; // nr_ob - numar obiecte
clrscr();
/*
printf("Dimensiuni fotografie (matrice), linii, coloane: ");
scanf("%d%d", &n, &m);
printf("Citire fotografie:\n");
for (il=1; il<=n; il++)
printf("F[%d, %d]=", il, ic);
scanf("%d", &F[il][ic])
}
*/
// matricea F, impreuna cu cele 2 linii si 2 coloane, care
// delimiteaza fotografia, si specifica iesirea din fotografie
// are dimensiunile (n+2)*(m+2)
F[0][ic]=0;
F[n+1][ic]=0;
}
for (il=1; il<=m; il++){
F[il][0]=0;
F[il][m+1]=0;
}
printf("\nFotografia are urmatoarea configuratie:\n\n");
for (il=1; il<n+1; il++){
printf("\t");
for (ic=1; ic<m+1; ic++)
printf("%2d", F[il][ic]);
printf("\n\n");
}
printf("\nCoordonate obiecte (stanga-sus):\n");
do
{il=0; // se cauta prima unitate in ordinea linii/coloane
do {
il++;
ic=0;
do
ic++;
while (ic<m+1 && F[il][ic]==0);
}while (il<n+1 && F[il][ic]==0);
if (F[il][ic] && ic<m+1 && il<n+1){ // conditie pusa pentru
printf("\n\tObiect %d: (%d,%d)\n", nr_ob+1, il, ic);
64
obiect(il, ic, F); // a evita apelul la terminarea
nr_ob++; // parcurgerii matricei
}
}while (il<n+1 || ic<m+1); // se reia parcurgerea pana matricea devine 0
printf("\n\tNumar obiecte: %i\n", nr_ob);
printf("\nApasati ENTER pentru a termina programul !");
getch();
}
/* orddiagn.c - programul permuta liniile dintr-o matrice pentru a ordona

crescator valorile de pe diagonala principala a matricei */
#include <stdio.h>
#include <conio.h>
#define NR_MAX 3
int a[NR_MAX][NR_MAX];
int nl, nc, l, c;
int ntotsol=0; // numarul total de solutii
void main (void)

{
int lin, col, il, ic, aux;
int incearca (int);
clrscr();
printf("Programul ordoneaza valorile de pe diagonala unei matrici.\n");
printf("Numar de linii/coloane: ");
scanf("%d%d", &nl, &nc);
printf("\n");
for (l=0; l<nl; l++)
for (c=0; c<nc; c++)
{
printf("a[%d,%d]=", l+1, c+1);
scanf("%d", &a[l][c]);
};
printf("\nApasati o tasat pentru a continua programul\n");
getch();
{// se aduce linia 'l' si coloana 'c' pe pozitia (0,0)
for (col=0; col<nc; col++)
{aux=a[0][col];
a[0][col]=a[l][col];
a[l][col]=aux;
};
for (lin=0; lin<nl; lin++)
65
{
aux=a[lin][0];
a[lin][0]=a[lin][c];
a[lin][c]=aux;
};
if (incearca(0)) // daca exista solutie (ord. diagonala)
ntotsol++; // se numara solutia si se tipareste
printf("\nSolutia %d:\n", ntotsol);
for (il=0; il<nl; il++)
{
for (ic=0; ic<nc; ic++)
printf("%4d", a[il][ic]);
printf("\n");
};
printf("\nApasati o tasta pentru a continua programul !\n");
getch(); // se duc la loc linia si coloana mutate anterior
for (col=0; col<nc; col++)
{aux=a[0][col];
a[0][col]=a[l][col];
a[l][col]=aux;
};
for (lin=0 ;lin<nl; lin++)
{aux=a[lin][0];
a[lin][0]=a[lin][c];
a[lin][c]=aux;
};
};
printf("\nNumarul total de solutii este %d.\n", ntotsol);
printf("\nApasati o tasta pentru a termina programul !\n");
getch();
};
int incearca (int i)

{
int lin, col, l, c;
int aux, q;
lin=col=i;
do
{
q=0;
if ((i > 0 && a[lin][col] >= a[i-1][i-1] ) || (i == 0))
{
{aux=a[i][c];
66
a[i][c]=a[lin][c];
a[lin][c]=aux;
};
{aux=a[l][i];
a[l][i]=a[l][col];
a[l][col]=aux;
};
if (i < nl-1)
{
q=incearca (i+1);
if (!q)
{
{aux=a[i][c];
a[i][c]=a[lin][c];
a[lin][c]=aux;
};
{aux=a[l][i];
a[l][i]=a[l][col];
a[l][col]=aux;
};
};
}
else
q=1;
};
if (col == nc-1)
{
col=i;
lin++;
}
else
col++;
} while (!q && lin < nl && col < nc);
return (q);
}
/* regine1s.c - programul furnizeaza o solutie (prima) pentru problema

asezarii a 8 regine pe tabla de sah, astfel incat nici una dintre ele
sa nu o atace pe alta (prima regina este amplasata in pozitia (1,1) */
#include <stdio.h>
#include <conio.h>
67
int a[9] = {0, 1, 1, 1, 1, 1, 1, 1, 1}; // indice a = linia 'k'
// initializarea pozitiilor, pe linii, de la 1 la 8 (0 nu este utilizata)
int b[17] = {0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// initializarea pozitiilor pentru diagonala dr-st, de la 2 la 16,
// pozitiile 0 si 1 nu sunt utilizate
int c[15] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// initializarea pozitiilor de la 0 la 14, pentru diagonala dr-st.
int x[9]; // vectorul pozitiilor pe coloane, indice x=linia, x[]=coloana
void incearca (int i, int *pq)

{int j;
j=0;
do
{
j++; *pq=0; // 0 inseamna ca nu este solutie buna
if (a[j] && b[i+j] && c[i-j+7]) // plasare corecta ?
{
x[i]=j; // memorare pozitie (linie, coloana), si
a[j]=0; b[i+j]=0; c[i-j+7]=0; // "activare" directii
if (i < 8) // de "atac" ale reginei respective
{
incearca (i+1, pq); // plasare regina urmatoare
if ( !(*pq) )
{// daca pozitionarea nu a fost buna
a[j]=1; b[i+j]=1; c[i-j+7]=1;// se sterg
} //"directiile" atacate de regina respectiva
}
else
*pq=1; // solutie completa
}
}while (!(*pq) && j !=8); // se reia cat timp solutia nu este buna
} // si nu s-au asezat 8 regine pe tabla de sah
void main (void)

{
int i, q;
clrscr();
incearca (1, &q);
for (i=1; i<= 8; i++)
printf("%4d", x[i]);
printf("\n");
}
/* reginets.c - programul furnizeaza toate solutiile pentru problema
asezarii a 8 regine pe tabla de sah, astfel incat nici una dintre ele
68
sa nu o atace pe alta (prima regina este amplasata in pozitia (1,1) */
#include <stdio.h>
#include <conio.h>
int a[9] = {0, 1, 1, 1, 1, 1, 1, 1, 1}; // indice a = linia 'k'
// initializarea pozitiilor, pe linii, de la 1 la 8 (0 nu este utilizata)
int b[17] = {0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// initializarea pozitiilor pentru diagonala dr-st, de la 2 la 16,
// pozitiile 0 si 1 nu sunt utilizate
int c[15] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// initializarea pozitiilor de la 0 la 14, pentru diagonala dr-st.
int x[9]; // vectorul pozitiilor pe coloane, indice x=linia, x[]=colaona
int ntotsol=0; // numarul total de solutii
void afiseaza (void)
{
int k;
printf("Sol. %2d: ", ntotsol+1);
for ( k = 1; k <= 8; k++)
printf("%4d", x[k]);
printf("\n");
ntotsol++; // contorizez numarul total de solutii
if (ntotsol%20 == 0){
printf("\nProgramul (si afisarea) continua! Apasati o tasta!\n");
getch();
}
}
void incearca (int i)

{
int j;
for (j=1; j<=8; j++)
if (a[j] && b[i+j] && c[i-j+7])
{x[i]=j; // memorare pozitie (linie, coloana), si
a[j]=0; b[i+j]=0; c[i-j+7]=0; // "activare" directii
if ( i < 8 ) // de "atac" ale reginei respective
incearca (i+1);
else
afiseaza (); // afiseaza solutia gasita
a[j]=1; b[i+j]=1; c[i-j+7]=1;// se sterg
} // "directiile" atacate de regina respectiva
}
void main (void)

{
clrscr();
69
incearca (1);
printf("\nNumarul tota de solutii gasite este %4d.\n", ntotsol);
printf("\nProgramul s-a terminat! Apasati o tasta!\n");
getch();
}
/* rucsacc.c - programul incarca un rucsac, utilizand metoda Greedy

(problema continua a rucsacului)*/
#include <stdio.h>
#include <conio.h>
#define DIM_MAX 20
void main()
{
float p[DIM_MAX], g[DIM_MAX], ef[DIM_MAX];
int n, i, j, inv, ordonat[DIM_MAX];
float gr, castig;
clrscr();
printf("Capacitate rucsac (greutate admisa): ");
scanf("%f", &gr);
printf("Numarul de obiecte ce trebuie incarcate in rucsac (disponibile): ");
scanf("%d", &n);
printf("Specificati pentru fiecare obiect greutatea/profitul:\n");
for(i=0;i<n;i++) /* citirea elementelor sirului de sortat */
{
printf("Greutate(%d)= ",i+1);
scanf("%f", &g[i]);
printf("Profit(%d) = ",i+1);
scanf("%f", &p[i]);
ordonat[i]=i;
ef[i]=p[i]*g[i];
}
do /* ordonez indici obiecte in vector ordonat, functie de eficienta */
{ /* utilizand metoda inversiunilor (bulelor) */
inv=0;
for (i=0; i < n-1; i++)
if (ef[ordonat[i]] < ef[ordonat[i+1]])
{
j=ordonat[i];
ordonat[i]=ordonat[i+1];
ordonat[i+1]=j;
inv=1;
}
} while (inv);
castig=0;
70
i=0;
printf("\nSe incarca in rucsac:\n");
while (gr > 0 && i < n)
{
if (gr >= g[ordonat[i]])
{
printf("\tObiect %d incarcat in intregime\n", ordonat[i]+1);
gr=gr - g[ordonat[i]];
castig=castig + p[ordonat[i]];
}
else
{printf("Obiect %d incarcat in proportie de"
" %.2f %\n", ordonat[i]+1, gr/g[ordonat[i]]*100);
castig=castig + p[ordonat[i]]*gr/g[ordonat[i]];
gr=0; // rucsacul este plin, greutate disponibila 0
}
i++;
}
printf("\nObiectele incarcate in rucsac sunt urmatoarele:\n");
for (j=0; j<i; j++)
printf("\tObiectul: %d, de greutate: %.2f si profit: %.2f\n",
ordonat[j]+1, g[ordonat[j]], p[ordonat[j]]);
if (gr){
printf("\nSe mai pot incarca obiecte de greutate: %.2f", gr);
printf("\n\t\t rucsacul nu este plin, dar nu mai sunt obiecte.\n");
}
printf("\nProfitul total obtinut pentru aceasta incarcare: %.2f\n", castig);
printf("\nApasati o tasta pentru a termina programul !!!\n");
getch();
}
/* sirmaxpd.c - programul determina cel mai mare subsir crescator,
dintr-un sir dat, utilizand "programarea dinamica"
*/
#include<stdio.h>
#include <conio.h>
#define DIM 100
void main(void){
int vmax, v[DIM]={1, 5, 2, 6, 7, 4, 10, 13, 9, 20, 14, 7, 15, 12, 17};
int n=15, i, k, max, imax, L[DIM], Lmax;
clrscr();
/*printf("Numar elemente:");
scanf("%d", &n);
for(i=0; i<n; i++) // citire sir unde caut cel mai mare subsir crescator
71
{
printf("v(%d)= ", i+1);
scanf("%d", &v[i]);
} */
L[n-1]=1;
/* calculez L[k]=L[i]+1, unde 'i' este indicele unde v[k]<=v[i] */
for (k=n-2; k>=0; k--){ // L[k] contine numarul max. de succesori pentru v[k]
L[k]=1; // determin pentru fiecare numar v[k]
imax=k; // care pot fi succesorii sai
Lmax=1; // selectand dintre acestia pe cei care ofera lungimea
for (i=k+1; i<n; i++) // maxima (L[k] va contine pentru pozitia k
if (v[k] <= v[i] && Lmax <= L[i]){ // numarul total
Lmax=L[i]; // de elemente din subsirul
imax=i; // crescator, maxim, ce se
L[k]=L[imax]+1; // poate forma
}
}
printf("Vectorul L este urmatorul:\n");
for (i=0; i<n; i++)
printf("%3i", L[i]);
printf("\n");
Lmax=L[0]; imax=0; // se determina inceputul subsirului crescator maxim
for (i=1; i<n; i++){ // acesta incepe de la pozitia corespunzatoare
if (Lmax < L[i]){ // pozitiei 'imax' a valorii maxime din L
Lmax=L[i];
imax=i;
}
}
printf("\nSubsirul cel mai lung este (incepe de la poz %d):\n", imax+1);
printf("%5d", v[imax]);
vmax=v[imax]; // prima valoare din subsirul cautat
Lmax=L[imax]; // dimensiunea subsirului de tiparit
for (i=imax+1; i<n; i++) // urmatoarea valoare din subsir este mai mare
if (vmax <= v[i] && L[i]==Lmax-1){ // decat cea anterioara
vmax=v[i]; // si are lungimea cu o unitate mai mica
printf("%5d ", vmax);
Lmax--; // actualizare dimensiune subsir ramas de tiparit
}
printf("\n\n\tApasati o tasta pentru a termina programul\t!!!\n");
getch();
}
/* sumvalv.c - programul citeste un vector de valori intregi
si determina daca o anumita valoarea (suma dorita) se poate furniza
prin insumarea valorilor din vector, si ofera toate solutiile posibile
72
- exemplu de backtracking */
#include <stdio.h>
#include <conio.h>
#define MAXV 16
typedef struct
{int nval, val[MAXV]; /* numar valori disponibile in vector */
long rest; /* si vectorul; rest (suma) de realizat */
int nrsol; /* numar solutii */
unsigned sel; /* marcaj valori selectate, prin setarea
bitului corespunzator pozitiei valorii selectate */
} TDate;
int nle=0; /* numar de linii afisate pe ecran */
void AfiSolutie (TDate *a)

{int i;
unsigned x;
printf ("%2i:", ++a->nrsol);
for (x = a->sel, i = 0; i < a->nval; i++, x >>= 1)
if (x & 1)
printf ("%4i", a->val[i]);
else
printf(" -");
printf("\n");
nle++;
if(nle%23==0)
{printf("Se continua afisarea dupa apasarea unei taste!\n");
getch();
}
}
/* cauta variante de completare a restului din solutia curenta

prin backtracking */
void Cauta (TDate *a, int iv) /* iv - indicele valorii analizate */
{if (a->rest == 0) /* solutie exacta */
{AfiSolutie (a); return;}
for (; iv < a->nval ; iv++) /* cat timp mai exista valori de analizat */
if (a->rest >= a->val[iv] ) /* valoarea iv este acceptabila */
{a->sel += (1 << iv);/* avans: marcheaza acceptare val[iv],
prin pozitionarea unui bit 1 pe pozitia iv */
a->rest -= a->val[iv]; /* si micsoreaza rest de completat */
Cauta (a, iv+1); /* continua cautarea */
a->sel -= (1 << iv); /* revenire: renunta la val[iv],
prin stergerea bitului 1 de pe pozitia iv */
73
a->rest += a->val[iv]; /* si reface rest de completat */
}
}
void main ()
{int i;
long Suma;
TDate x;
clrscr();
printf ("Introduceti valori, terminand cu 0 sau caracter nenumeric:\n");
for (i = 0; i < MAXV; i++)
if (scanf("%i", &(x.val[i])) < 1 || x.val[i] == 0)
break;
if (!i)
{ printf ("Lipsa date!!!\n"); exit(1); }
x.nval = i;
printf("\nAti introdus %u valori:\n", x.nval);
for (i = 0; i < x.nval; i++)
printf ("%5i", x.val[i]);
printf ("\n");
for (;;)
{printf ("\nSuma dorita de construit (calculat) cu valori "
"din vector\n\t(oprire program orice caracter nenumeric): ");
fflush(stdin);
if (!scanf ("%ld", &Suma))
break;
x.sel = 0; x.rest = Suma; x.nrsol = 0;
Cauta (&x, 0); /* Cauta solutii */
if (! x.nrsol)
printf ("Nu exista solutie !\n");
}
}
/*t_hanoi.c - Problema 'Turnurilor din Hanoi', rezolvata recursiv */
#include <stdio.h>
#include <conio.h>
enum pozitie { stanga , mijloc , dreapta};
void tipareste_pozitie ( enum pozitie poz )

{
switch ( poz )
{
case 0 : printf ( "stanga" );/* se poate case stanga */
break;
case 1 : printf ( "mijloc" );
74
break;
case 2 : printf ( "dreapta" );
}
}
void deplasare( enum pozitie sursa , enum pozitie dest )

{
printf ( "muta un disc din " );
tipareste_pozitie ( sursa );
printf ( " in " );
tipareste_pozitie ( dest );
printf ( "\n" );
return;
}
void muta ( int n, enum pozitie sursa, enum pozitie inter, enum pozitie dest )
{
if ( n > 0 )
{
muta ( n - 1 , sursa , dest , inter );
deplasare ( sursa , dest );
muta ( n - 1 , inter, sursa , dest );
}
}
void main (void)

{
int i , nd;
clrscr();
printf ( "Nr. de discuri :" );
scanf ("%d", &nd);
while ( getchar() != '\n' );
printf ("Mutarile pt. deplasarea unui turn cu %d discuri sunt :\n", nd);
muta ( nd , stanga , mijloc , dreapta );
printf("\n\n");
}
/*taieturi.c - Problema taieturilor, exemplu de algoritm "divide et impera"

Se considera un dreptunghi dat prin coltul din stanga jos (x,Y) si
dimensiunile sale l-lungime, h-latime/inaltime. In interiorul sau se afla
'n' gauri de coordonate (xg, yg), memorate intr-un vector. Se cere sa se
determine un dreptunghi de dimensiuni maxime, care sa nu contina gauri,
prin realizarea de decupari/ taieturi verticale sau orizontale ale
dreptunghiului initial prin gaurile sale. */
75
#include <stdio.h>
#include <conio.h>
#define MAXG 5
int n=4;
void dreptunghi (int x, int y, int l, int h,
int *px, int *py, int *pl, int *ph, int xg[], int yg[]){
int gasit, i;
i=0; gasit=0;
while (i<n && !gasit) // exista gaura in dreptunghiul ((x,y), l, h) ?
if (xg[i] > x && xg[i] < x+l && yg[i] > y && yg[i] < y+h)
gasit=1;
else
i++;
if (gasit) // daca da, avem 2 taieturi -> 4 dreptunghiuri
{dreptunghi(x, y, xg[i]-x, h, px, py, pl, ph, xg, yg);
dreptunghi(xg[i], y, l+x-xg[i], h, px, py, pl, ph, xg, yg);
dreptunghi(x, y, l, yg[i]-y, px, py, pl, ph, xg, yg);
dreptunghi(x, yg[i], l, h+y-yg[i], px, py, pl, ph, xg, yg);
}
else if (l*h > *pl* *ph) // se compara aria drept. cu cea a drept. taiat
{*px=x; *py=y; // daca acesta nu mai contine gauri (!gasit)
*pl=l; *ph=h;
}
}
void main (void)

{
int xg[MAXG]={1, 2, 3, 4}, yg[MAXG]={1, 2, 3, 4};
int l=5, h=5;
int *px, *py, lmax=0, hmax=0;
clrscr();
dreptunghi(0, 0, l, h, px, py, &lmax, &hmax, xg, yg);
printf("\nDreptunghiul maxim este: (x,y) stanga-jos = (%d, %d)\n\t\t\t"
"lung (dx) = %d, latime (dy sau h) = %d\n", *px, *py, lmax, hmax);
printf("\nApasati o tasta pentru a termina programul !!!\n");
getch();
}
/* tripasca.c - programul determina tabloul coeficientilor

binomului (a+b)^n, adica combinbari de n luate cate k,
Tabloul coeficientilor este urmatorul:
0 1 2 3 4 5 6 7 8
1 1 1
2 1 2 1
76
3 1 3 3 1
4 1 4 6 4 1
5 1 5 10 10 5 1
6 1 6 15 20 15 6 1
7 1 7 21 35 35 21 7 1
care utilizeaza relatiile:

C(n,k)=C(n-1,k-1) + C(n-1, k), C(k,k)=1, C(k,1)=1
si C(k,j)=1, pentru j>k
Utilizand "programarea dinamica" vom pastra linia curenta
din tablou intr-un vector si vom calcula linia urmatoare
din tablou in acelasi vector, de la dreapta la stanga,
observand ca un nou termen este suma precedentilor doi,
cu exceptia celor doua valori extreme, care sunt 1.
*/
#include<stdio.h>
#include <conio.h>
#define DIM 80
void main(void){
long int c[DIM];
int n=15, i, k, d;
clrscr();
for (k=0; k<=n; k++){ // construire vector v, linia n, din triunghi Pascal
for (i=k; i>=0; i--) // construire linie k din tringhiul Pascal
if (i==k)
c[i]=1;
else if (i==0)
c[i]=1;
else
c[i] += c[i-1];
printf("\n\n%2i", k); // afisare linie k
d=3; // spatiu initial rezervat pentru afisarea unei valori
for (i=0; i<=k; i++){
printf("%*li", d, c[i]);
if (i < (n+1)/2) // pentru valori mai mari ale lui n
{if(i%2) // se incrementeaza la cresterea lui
d++; // i spatiul d (din 2 in 2, cu 1)
}
else if((i+1)%2) // iar pentru partea a doua a
d--; // triunghiului se reduce spatiul
} // cu acelasi pas; pentru n>20 trebuie
if ((k+1)%16 == 0){ // modificat 'd' cu un pas mai mare
77
printf("\n\nContinua afisarea dupa apasarea unei taste!\n");
getch();
}
}
printf("\n");
printf("\n\n\tApasati o tasta pentru a termina programul\t!!!\n");
getch();
}
/* ArbCsMin.c - programul construieste un arbore partial de cost minim

pentru un graf neorientat, utilizand algoritmul lui Prim
*/
#include <stdio.h>
#include <conio.h>
#include <values.h>
#define DIMN 10 // numar maxim noduri
#define DIMM 100 // numar maxim muchii
void citire_graf (int a[DIMN+1][DIMN+1], int *pn, int *pm){

int i, j, k, cost;
clrscr();
printf("\nDati numar noduri, graf neorientat, n: ");
scanf("%d", pn);
printf("Nr. de muchii: ");
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
a[i][j]=0; // initializare matrice drumuri (costuri) pt. graf
printf("\nCitire graf prin muchiile sale.\n");
for (k=1; k<= *pm; k++)
{
printf("Muchie, varfuri sursa, dest: ");
scanf ("%d%d", &i, &j);
printf("\tCost(%d-%d)= ", i, j);
scanf("%d", &cost);
a[j][i]=a[i][j]=cost; // pt. graf neorientat cost (i,j)=cost(j,i)
}
}
void construct_arb_cost_min (int a[DIMN+1][DIMN+1], int ARB[DIMM+1],

int P[DIMM+1], int C[DIMN+1], int n, int prim){
int k, i, j, cost_min, v1, v2;
for (i=1; i<=n; i++){ // initializare vectori V, P, C cu 0
78
ARB[i]=0; C[i]=0; P[i]=0;
}
ARB[prim]=1; // initializare varf de inceput
for (k=1; k<=n-1; k++){ // se dermina celalate n-1 varfuri ale arborelui
cost_min=MAXINT;
v1=0; v2=0;
for (i=0; i<=n; i++)
for (j=0; j<=n; j++)
if (ARB[i]==1 && ARB[j]==0)// i e in arbore, iar j nu
if(a[i][j]) // si i-j este muchie in graf cu
if (a[i][j]<cost_min){ // cost minim
cost_min=a[i][j];
v1=i; v2=j; // retin muchia
} // in v1-v2
ARB[v2]=1; // adaug varful de cost minim in arborele ARV
P[v2]=v1; // parintele lui 'v2' este 'v1'
C[v2]=cost_min; // retin costul minim pt v1-v2 in C
}
}
void tip_arb_cost_min (int C[DIMN+1], int P[DIMN+1], int nn){

int i, cm=0;
for (i=2; i<nn; i++){ // tiparim parintele-varful si costul ramurii
printf("%2d -%2d (%d) / ", P[i], i, C[i]);
cm+=C[i];
}
cm+=C[nn];
printf("%2d - %2d (%d)\n\t\tcost minim = %d\n", P[i], i, C[i], cm);
}
void main()
{
int a[DIMN+1][DIMN+1]; // matricea de adiacenta (costuri/ drumuri)
int ARB[DIMN+1], C[DIMN+1], P[DIMN+1]; // ARB-arb partial, P-parinti, C-cost
int n, nm, primul, dimV, k;
citire_graf (a, &n, &nm);
printf("\nProgramul parcurge in latime graful.\n");
printf("\nSpecificati varful de start pentru parcurgere: ");
scanf("%d", &primul);
construct_arb_cost_min (a, ARB, P, C, n, primul);
printf("\nArborele de cost minim este urmatorul:\n");
tip_arb_cost_min (C, P, n);
printf("\nApasati o tasta pentru a termina programul\n");
getch();
79
}
/* ciclugrf.c - programul determina toate ciclurile elementare dintr-un

graf cu n noduri si m muchii,
*/
#include <stdio.h>
#include <conio.h>
typedef struct{
int v1, v2; // cele doua varfuri ale unei muchii
} VECT_MUCHII;
int nr_sol=0;
void citire_graf (VECT_MUCHII vm[DIMM+1], int a[DIMN+1][DIMN+1], int *pn, int *pm){
int i, j, k;
clrscr();
scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
for (k=1; k<= *pm; k++)
{
printf("Muchia %d, varfuri: ", k);
scanf ("%d%d", &vm[k].v1, &vm[k].v2); // costul (i,j)=cost(j,i)
a[vm[k].v1][vm[k].v2]=a[vm[k].v2][vm[k].v1]=1;
}
}
void init_ciclu (int ciclu[DIMM+1], int nm){

int i;
for (i=1; i<=nm; i++)
ciclu[i]=0;
}
void tipar_ciclu(int ciclu[DIMM+1], int p){

int i;
for (i=1; i<p; i++) // tipareste ciclul 'p'
80
printf("%d -> ", ciclu[i]);
printf("%d\n", ciclu[p]);
if ((nr_sol+1)%20==0){
printf("\nAfisarea continua dupa apasarea unei taste !!!\n");
getch();
}
}
int validare_ciclu (int a[DIMN+1][DIMN+1], int ciclu[DIMM+1], int p){

int k;
if ( !a[ciclu[p]][ciclu[p-1]] ) // daca nu exista muchia -> nu e valid ciclul
return 0;
for (k=2; k<p; k++) // daca varful mai exista in solutia 'ciclu', pana
if (ciclu[k] == ciclu [p]) // la pozitia 'p-1' -> nu e solutie corecta
return 0;
return 1;
}
void incerc_ciclu(int a[DIMN+1][DIMN+1], int ciclu[DIMM+1], int n, int p){

int i;
for (i=1; i<=n; i++)
{ciclu[p]=i;
if (validare_ciclu(a, ciclu, p))
if (ciclu[p]==ciclu[1] && p>3) // solutie completa
{tipar_ciclu(ciclu, p); // (nod final = nod initial
nr_sol++; // si sunt cel putin 3 noduri)
}
else
incerc_ciclu(a, ciclu, n, p+1);
// ciclu[p]=0; // sterge ciclul incercat
}
}
void main()
{
VECT_MUCHII vm[DIMM+1]; // vectorul de muchii (muchie=doua varfuri)
int ciclu[DIMM+1], a[DIMN+1][DIMN+1]; // vect culori si matricea de adiacenta
int n, nm;
citire_graf (vm, a, &n, &nm);
printf("\nCiclurile din graf sunt urmatoarele:\n");
init_ciclu(ciclu, nm);
incerc_ciclu(a, ciclu, n, 1);
if(nr_sol)
printf("\nNumarul total de solutii este: %d\n", nr_sol);
81
else
printf("\nProblema nu are solutii");
printf("\n");
}
/* colorgrf.c - programul determina toate solutiile pentru colorarea celor

m muchii ale unui graf cu n noduri, utilizand c culori diferite,
cu restrictia ca doua muchii ce se intersecteaza intr-un nod sa
nu aiba aceeasi culoare
Graful este reprezentat ca un vector de muchii
*/
#include <stdio.h>
#include <conio.h>
typedef struct{
int v1, v2; // cele doua varfuri ale unei muchii
} VECT_MUCHII;
int nr_sol=0;
void citire_graf (VECT_MUCHII vm[DIMM+1], int a[DIMN+1][DIMN+1], int *pn, int *pm){
int i, j, k;
clrscr();
scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
for (k=1; k<= *pm; k++)
{
printf("Muchie: varfuri sursa, dest: ");
scanf ("%d%d", &vm[k].v1, &vm[k].v2);
a[vm[k].v1][vm[k].v2]=a[vm[k].v2][vm[k].v1]=1; // costul (i,j)=cost(j,i)
}
}
void tipar_culoare(int culoare[DIMM+1], VECT_MUCHII vm[DIMM+1], int nm){

int i;
for (i=1; i<=nm; i++) // tipareste culoarea pentru muchia 'i', specificand
82
if (vm[i].v1 < vm[i].v2) // varful sursa si cel destinatie, in ordine
printf("m(%d-%d)=c%d, ", vm[i].v1, vm[i].v2, culoare[i]);
else
printf("m(%d-%d)=c%d, ", vm[i].v2, vm[i].v1, culoare[i]);
printf("\n");
if ((nr_sol+1)%20==0){
printf("\nAfisarea continua dupa apasarea unei taste !!!\n");
getch();
}
}
int validare_culoare (VECT_MUCHII vm[DIMM+1], int culoare[DIMM+1], int p){

int val=1, k;
for (k=1; k<p; k++)
if (culoare[k] == culoare [p])
if (vm[k].v1==vm[p].v1 || vm[k].v1==vm[p].v2 ||
vm[k].v2==vm[p].v1 || vm[k].v2==vm[p].v2)
val=0;
return val;
}
void incerc_culoare(VECT_MUCHII vm[DIMM+1], int culoare[DIMM+1], int c, int nm, int p){
int i, j;
for (i=1; i<=c; i++)
{culoare[p]=i;
if (validare_culoare(vm, culoare, p))
if (p==nm) // solutie completa (toate nodurile colorate)
{tipar_culoare(culoare, vm, nm);
nr_sol++;
}
else
incerc_culoare(vm, culoare, c, nm, p+1);
// culoare[p]=0; // sterge culoarea incercata
}
}
void main()
{
int culoare[DIMM+1], a[DIMN+1][DIMN+1]; // vect culori si matricea de adiacenta
int n, nm, c;
printf("\nNumarul de culori cu care se coloreaza: ");
scanf("%d", &c);
83
incerc_culoare(vm, culoare, c, nm, 1);
if(nr_sol)
else
printf("\n");
}
/* elimgraf.c - programul elimina noduri dintr-un graf, cu conditia

ca suma drumurilor pentru nodurile ramase sa fie cuprinsa intre
doua limite.
Se considera graf cu n noduri si m muchii, ce reprezinta configuratia
in teritoriu a unei companii impreuna cu sucursalele sale. Sucursalele
sunt interconectate intre ele prin drumuri de lungime data.
Matricea de adiacenta contine costurile (drumurile) intre aceste
filiale. Se doreste renuntarea la un numar de filiale, astfel incat
suma drumurilor intre filialele ramase sa fie cuprinsa intre 2 valori
*/
#include <stdio.h>
#include <conio.h>
typedef struct{ // cele doua varfuri ale unui arc orientat

int vi, vf; // vi, vf - varfurile initial si final al arcului
int lung; // lungimea drumului intre cele doua varfuri
} VECT_MUCHII;
int nr_sol=0;
void citire_graf (VECT_MUCHII vm[DIMM+1], int a[DIMN+1][DIMN+1],

int *pn, int *pm){
int i, j, k, drum;
clrscr();
printf("\nDati numar noduri, graf orientat, n: ");
scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
a[i][j]=0; // init.(0) matrice drumuri (costuri) pt. graf
for (k=1; k<= *pm; k++)
{
84
printf("Muchia %d, varf sursa -> destinatie: ", k);
scanf ("%d%d", &vm[k].vi, &vm[k].vf);
printf("Cost (%d -> %d)= ", vm[k].vi, vm[k].vf);
scanf ("%d", &drum);
a[vm[k].vi][vm[k].vf]=vm[k].lung=drum;
}
printf("\nMatricea drumurilor pentru graful introdus este:\n");
for (i=1; i<=*pn; i++){
for (j=1; j<=*pn; j++)
printf("%3d", a[i][j]);
printf("\n");
}
}
void init_solutie (int solutie[DIMM+1], int nm){

int i; // initializeaza solutia cu 0
for (i=1; i<=nm; i++)
solutie[i]=0;
}
int suma_drum_sol(int a[DIMN+1][DIMN+1], int solutie[DIMM+1],

int p, int dmin, int dmax){
int k, suma_drum=0; // drumul total al solutiei determinate
for (k=1; k<p; k++)
suma_drum+=a[solutie[k]][solutie[k+1]];
if (suma_drum >= dmin && suma_drum <= dmax)
return suma_drum; // daca satisface conditia returneaza suma
return 0; // altfel returneaza 0
}
void tipar_solutie(int a[DIMN+1][DIMN+1], int solutie[DIMM+1],

int p, int dmin, int dmax){
int i;
for (i=1; i<p; i++) // tipareste solutia 'p'
printf("%d -> ", solutie[i]);
printf("%d\n\tSuma drumurilor=%d\n", solutie[p],
suma_drum_sol(a, solutie, p, dmin, dmax));
if ((nr_sol+1)%10 == 0){ // s-a afisat un ecran, continua ? -> apasa tasta
printf("\nAfisarea continua dupa apasarea unei taste!\n");
getch();
}
}
85
int validare_solutie (int a[DIMN+1][DIMN+1], int solutie[DIMM+1], int p){
int k;
if ( !a[solutie[p-1]][solutie[p]] ) // daca nu e drum -> nu e valida solutia
return 0;
for (k=2; k<p; k++) // daca varful mai exista in 'solutia' pana la
if (solutie[k]==solutie[p]) // pozitia 'p-1' -> nu e solutie corecta
return 0; // varful mai poate fi doar pe prima pozitie
return 1;
}
void incerc_solutie(int a[DIMN+1][DIMN+1], int solutie[DIMM+1],

int n, int p, int dmin, int dmax){
int i;
for (i=1; i<=n; i++)
{solutie[p]=i; // initializare varf pe pozitia 'p'
if (validare_solutie(a, solutie, p))
if (solutie[1] == solutie[p] && p > 3 && // sol completa ?
suma_drum_sol(a, solutie, p, dmin, dmax))
{tipar_solutie(a, solutie, p, dmin, dmax);
nr_sol++;
}
else
incerc_solutie(a, solutie, n, p+1, dmin, dmax);
solutie[p]=0; // sterge ciclul incercat
}
}
void main()
{
int sol[DIMM+1], a[DIMN+1][DIMN+1]; // vect culori si matricea de adiacenta
int n, nm, dmin, dmax;
printf("Limitele pentru suma drumurilor din graf (min, max): ");
scanf("%d%d", &dmin, &dmax);
init_solutie(sol, nm);
printf("\nSolutiile din graf sunt urmatoarele:\n");
incerc_solutie(a, sol, n, 1, dmin, dmax);
if(nr_sol)
else
printf("\n");
}
86
/* LantGraf.c - programul determina daca exista un lant dat intr-un graf */
#include <stdio.h>
#include <conio.h>
void citire_graf (int a[DIMN+1][DIMN+1], int *pn, int *pm){

int i, j, k;
clrscr();
scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
for (k=1; k<= *pm; k++)
{
printf("Muchie sursa, dest: ");
scanf ("%d%d", &i, &j);
a[j][i]=a[i][j]=1; // pt. graf neorientat costul (i,j)=cost(j,i)
}
}
void citire_lant(int l[DIMM+1], int *pdl){

int i;
printf("\nDati numar noduri pentru lantul de testat: ");
scanf("%d", pdl);
for (i=1; i<= *pdl; i++)
{
printf("Varful %d din lant: ", i);
scanf ("%d", &l[i]);
}
printf("\nLantul cautat in garf este urmatorul:\n");
for (i=1; i<= *pdl; i++)
printf("%d -> ", l[i]);
}
int test_lant(int g[DIMN+1][DIMN+1], int l[DIMM+1], int dl, int *elem){

int i, j;
*elem=1; // initializam cu 1 (presupunem ca este lant elementar)
for (i=1; i<=dl; i++)
if (!g[l[i]][l[i+1]])
87
return 0; // nu este lant, un varf nu este in matrice
for (i=1; i<=dl-1; i++)
for (j=i+1; j<=dl; j++)
if(l[i]==l[j])
*elem=0; // este ne-elementar
return 1;
}
void main()
{
int a[DIMN+1][DIMN+1], l[DIMM+1]; // matricea de adiacenta si lantul cautat
int n, nm, dl, elementar;
citire_graf (a, &n, &nm);
citire_lant (l, &dl);
if (test_lant(a, l, dl, &elementar)){
printf("\n\nEste un lant ");
if (!elementar)
printf("ne-");
printf("elementar!\n");
}
else
printf("\n\nNu este un lant in graf !!!\n");
printf("\n");
}
//POPA ALEXANDRU GABRIEL 314AB

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
88
#include<math.h>
#include<ctype.h>
struct punct
{
int x;
int y;
};
typedef struct punct pct;
int main(int argc,char **argv)
{
int x1,x2,x3,y1,y2,y3,r1,r2,r3;
int nr,i,j,k,locatie1,locatie2;
int **m,X,Y,i1,i2,D,*cost,*parinte,cost_temp;
pct *a;
char nume_locatie[16],nume_satelit[16],*c,**v;
FILE *Coordonate,*Avarii,*Coordonate_Finale,*Rezultat;
Coordonate = fopen(argv[1],"rt");
if(Coordonate == NULL)
{
printf("Fisierul coordonate.in nu a putut fi deschis!");
exit(1);
}
Coordonate_Finale = fopen(argv[4],"wt");
if(Coordonate_Finale == NULL)
{
printf("Fisierul coord_finale.out nu a putut fi deschis!");
exit(1);
}
fscanf(Coordonate,"%d",&nr);
a = (pct*)malloc(nr*sizeof(pct));
v = (char**)malloc(nr*sizeof(char*));
for(i=0;i<nr;i++)
v[i] = (char*)malloc(16*sizeof(char));
for(i=0;i<nr;i++)
{
fscanf(Coordonate,"%s",nume_locatie);
strcpy(v[i],nume_locatie);
fscanf(Coordonate,"%s",nume_satelit);
fscanf(Coordonate,"%d%d%d",&x1,&y1,&r1);
89
i1 = r2*r2-r1*r1+x1*x1-x2*x2+y1*y1-y2*y2;
i2 = r3*r3-r1*r1+x1*x1-x3*x3+y1*y1-y3*y3;
D = 4*(x1-x2)*(y1-y3)-4*(y1-y2)*(x1-x3);
X = (2*i1*(y1-y3) - 2*i2*(y1-y2))/D;
Y = (2*i2*(x1-x2) -2*i1*(x1-x3))/D;
a[i].x = X;
a[i].y = Y;
fprintf(Coordonate_Finale,"%d %d\n",X,Y);
}
m = (int**)malloc(nr*sizeof(int*));
for(i=0;i<nr;i++)
m[i] = (int*)malloc(nr*sizeof(int));
for(i=0;i<nr;i++)
for(j=0;j<nr;j++)
{
m[i][j] = sqrt( (a[i].x - a[j].x)*(a[i].x - a[j].x) + (a[i].y - a[j].y)*(a[i].y - a[j].y) );
}
Avarii = fopen(argv[2],"rt");
if(Avarii == NULL)
{
printf("Fisierul avarii.in nu a putut fi deschis!");
exit(1);
}
while(fscanf(Avarii,"%s",nume_locatie) != EOF)
{
for(i=0;i<nr;i++)
{
if(strcmp(v[i],nume_locatie) == 0)
locatie1 = i;
}
fscanf(Avarii,"%s",nume_locatie);
for(i=0;i<nr;i++)
{
if(strcmp(v[i],nume_locatie) == 0)
locatie2 = i;
}
m[locatie1][locatie2] = 9999;
m[locatie2][locatie1] = 9999;
}
fclose(Avarii);
90
cost = (int*)malloc(nr*sizeof(int));
parinte = (int*)malloc(nr*sizeof(int));
cost[0] = 0;
for(i=1;i<nr;i++)
{
cost[i] = 9999;
parinte[i] = 0;
}
for(j=0;j<nr;j++)
for(k=0;k<nr;k++)
{
cost_temp = cost[j] + m[j][k];
if(cost_temp < cost[k])
{
cost[k] = cost_temp;
parinte[k] = j;
}
}
Rezultat = fopen(argv[5],"wt");
if(Rezultat == NULL)
{
printf("fisierul rezultat nu a putut fii creeat!");
exit(1);
}
for(i=0;i<nr;i++)
if(strcmp(argv[3],v[i]) == 0)
fprintf(Rezultat,"%d",cost[i]);
free(cost);
free(a);
for(i=0;i<nr;i++)
free(v[i]);
free(v);
for(i=0;i<nr;i++)
free(m[i]);
free(m);
free(parinte);
fclose(Rezultat);
fclose(Coordonate_Finale);
fclose(Coordonate);
return 0;
}
//Popa Alexandru Gabriel 314AB
#include "comoara.h"
#include<stdio.h>
91
#include<stdlib.h>
#include<string.h>
unsigned int seed = 0;
/* valoarea de plecare pentru functia rand() */
int main(int argc,char* argv[])

{
/* structura in care vom retine TOATE datele citite din fisier */
structura_date_intrare input;
int i,j;
/* alocam spatiu pentru numele fisierelor pentru IN/OUT */

char *numeInput = alocaSirCaractere(LUNGIME_NUME_FISIER);
char *numeOutput = alocaSirCaractere(LUNGIME_NUME_FISIER);
/* verificam si salvam numele fisierelor */

verificaArgument(argc,argv,numeInput,numeOutput);
/* citeste datele din fisierul de intrare */
input = citesteInput(numeInput);
/* rezolva si scrie in fisierul de iesire */
rezolvaSiScrieOutput(input,numeOutput);
/* eliberam memoria alocata anterior */

eliberareSirCaractere(numeInput);
eliberareSirCaractere(numeOutput);
eliberareMatrice(input.m,input.n);
return 0;
}
/**Functia eliberareMatrice
* Primeste matricea M de dimensiune (n x n).
*/
void eliberareMatrice(long long int **m,int n)
{
int i;
for(i=0;i<n;i++)
free(m[i]);
free(m);
}
/**Functia eliberareSirCaractere
* Primeste vectorul de caractere v.
*/
void eliberareSirCaractere(char *v)
{
free(v);
92
}
/**Functia alocaMatrice
* primeste ca parametru n = dimensiunea matricei
* intoarce o matrice n x n (adresa pozitiei de inceput)
*/
long long int **alocaMatrice(int n)
{
long long int **m = NULL,i;
m = (long long int**)malloc(n*sizeof(long long int*));
for(i=0;i<n;i++)
m[i] = (long long int*)malloc(n*sizeof(long long int));
return m;
}
/**Functia alocaSirCaractere
* Primeste ca parametru n = lungimea sirului de caractere.
*
* Intoarce un vector de n caractere (adresa pozitiei de inceput).
*/
char* alocaSirCaractere(int n)
{
char *v = NULL;
v = (char*)malloc(n*sizeof(char));
return v;
}
/**Functia citesteInput
* Primeste numele fisierului de intrare.
*
* Intoarce un element de tip structura_date_intrare cu datele citite.
*/
structura_date_intrare citesteInput(char *numeFisier)
{
structura_date_intrare in;
int i,j;
FILE *f;
f = fopen(numeFisier,"rt");
if(f == NULL)
{
printf("Fisierul de input nu a putut fi deschis! :( \n");
exit(1);
}
for(i=0;i<4;i++)
fscanf(f,"%d",&in.c[i]);
fscanf(f,"%d",&in.n);
fscanf(f,"%lli",&in.sumaMax);
93
in.m = alocaMatrice(in.n);
for(i=0;i<in.n;i++)
for(j=0;j<in.n;j++)
fscanf(f,"%lli",&in.m[i][j]);
fscanf(f,"%d",&in.numarMaxIncercari);
fclose(f);
return in;
}
void verificaArgument(int argc,char *argv[],char *numeIntrare,char *numeIesire)

{
if(argc == 3)
{
strcpy(numeIntrare,argv[1]);
strcpy(numeIesire,argv[2]);
}
}
/**Functia scrieOutput
* Primeste
* -un element cu datele de intrare;
* -un vector cu rezultatele ce vor fi scrise in fisier;
* -numele fisierului de iesire in care vom scrie.
*/
void scrieOutput(structura_date_intrare in,long long int rezultatCerinta[],char* numeIesire)
{
FILE *f;
f = fopen(numeIesire,"wt");
if(f == NULL)
{
printf("Fisierul de output nu a putut fi creat :( \n");
exit(1);
}
fprintf(f,"%lli",rezultatCerinta[0]);
if(in.c[1] == 1)
fprintf(f,"\n%lli",rezultatCerinta[1]);
if(in.c[2] == 1)
if(in.c[3] == 1)
fclose(f);
}
/**Functia rezolvareCerintaGreedy
* Primeste ca parametru un element cu toate datele de intrare.
*
94
* Intoarce rezultatul pentru cerinta 1.
*/
long long int rezolvareCerintaGreedy(structura_date_intrare in)
{
int n = in.n;
long long int **m = in.m;
int i,j;
long long int suma = 0;
i = n-1;
j = n-1;
suma = suma + m[i][j];
while(i != 0 || j!= 0)
{
if(i == 0)
j--;
else if(j == 0)
i--;
else if(m[i][j-1] < m[i-1][j])
j--;
else if(m[i][j-1] >= m[i-1][j])
i--;
}
return suma;
}
/**Functia rezolvareCerintaPD
*
*/
long long int rezolvareCerintaPD(structura_date_intrare in)
{
int n = in.n;
long long int rezultatFinal = 0;
long long int **pd;
pd = alocaMatrice(n);
int i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
pd[i][j] = 0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
95
if(pd[i][j] == 0)
{
if(i == 0 && j == 0)
{
pd[i][j] = m[i][j];
}
else if(i == 0)
pd[i][j] = m[i][j] + pd[i][j-1];
else if(j == 0)
pd[i][j] = m[i][j] + pd[i-1][j];
else if(pd[i][j-1] < pd[i-1][j])
pd[i][j] = m[i][j] + pd[i][j-1];
else if(pd[i][j-1] >= pd[i-1][j])
pd[i][j] = m[i][j] + pd[i-1][j];
}
}
rezultatFinal = pd[n-1][n-1];
eliberareMatrice(pd,n);
return rezultatFinal;
}
int rand()
{
seed = (MULTIP * seed + INCREMENT) % MODULATOR;
return seed;
}
/**Functia rezolvareCerintaSimulare
*
*/
long long int rezolvareCerintaSimulare(structura_date_intrare in)
{
int nrMaxIncercari = in.numarMaxIncercari;
int n = in.n;
long long int sumaMax = in.sumaMax;
long long int suma,rezultatFinal,nrIncercari = 0;
int i,j;
while(nrIncercari <= nrMaxIncercari)

{
nrIncercari++;
suma = 0;
96
i = n-1;
j = n-1;
while(i != 0 && j != 0)
{
if(rand() % 2)
i--;
else j--;
}
if(i == 0)
while(j != 0)
{
j--;
}
if(j == 0)
while(i != 0)
{
i--;
}
if(suma <= sumaMax)
break;
}
rezultatFinal = nrIncercari;
if(nrIncercari >= nrMaxIncercari)
{
rezultatFinal = 0;
}
return rezultatFinal;
}
/*Functia back contorizeaza drumurile sigure gasite
*/
long long int contorC4 = 0;
void back(long long int suma,long long int sumaMax,long long int **m,int i,int j)
{
if(j > 0)
back(suma,sumaMax,m,i,j-1);
if(i > 0)
back(suma,sumaMax,m,i-1,j);
if(i == 0 && j == 0)
97
if(suma <= sumaMax)
contorC4++;
}
/**Functia rezolvareCerintaBacktracking
*/
long long int rezolvareCerintaBacktracking(structura_date_intrare in)
{
int n = in.n;
long long int sumaMax = in.sumaMax;
int startLinie = n-1;
int startColoana = n-1;
long long int suma = 0;
back(suma,sumaMax,m,startLinie,startColoana);
return contorC4;
}
void rezolvaSiScrieOutput(structura_date_intrare in,char* fisierIesire)

{
long long int rezultatCerinta[VECTOR_CERINTE];
if(in.c[0])
rezultatCerinta[0] = rezolvareCerintaGreedy(in);
if(in.c[1])
rezultatCerinta[1] = rezolvareCerintaPD(in);
if(in.c[2])
rezultatCerinta[2] = rezolvareCerintaSimulare(in);
if(in.c[3])
rezultatCerinta[3] = rezolvareCerintaBacktracking(in);
scrieOutput(in,rezultatCerinta,fisierIesire);
}
98

Sdaawa

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sdaawa

Enviado por

Direitos autorais:

Formatos disponíveis

Portofoliu S.D.A.

Popa Alexandru Gabriel

void citire_text(FILE *f,char nume[],nod **CapDeLista)

void move(nod **cursor,int n)

void insert_string(nod **cursor, char *string)

void sterge_n(nod *cursor,int n)

void copy_n(nod *cursor,int n,char **buffer)

int copiaza_lista(nod *cap,nod **capcopy)

int pop_stiva(stiva *stack,nod **cap,int *pozitie)

void find_replace(nod *cap,char *cuvant1,char *cuvant2)

void free_mem(nod *cap,stiva *undo,stiva *redo)

int main(int argc,char ** argv)

void actualizare (struct st_arbore * arb , char *cuv){

void tiparire_arbore (struct st_arbore *arbo)

/* coadacuv.c - programul construieste o coada de cuvinte,

void extragere ( struct st_cuvant * primu)

/* coadatab.c - operatii cu o coada realizata static intr-un tablou;

typedef int ElTip; // ElTip - definire tip element din coada

void eroare (char *meserr){

int IncIndexC (int i){ /* increment index element curent coada */

void InitCoada (ACoada pc){

int CoadaGoala (ACoada pc){

int CoadaPlina (ACoada pc){

void AdaugElC (ACoada pc, ElTip el){

ElTip ScotElC (ACoada pc){

ElTip CapCoada (ACoada pc){

void AfisareCoada (ACoada pc){

void Afisare_Poz_Prim_Ultim (ACoada pc){

void main (void){

typedef int ElTip; // ElTip - definire tip element din coada

void eroare (char *meserr){

int IncIndexC (int i){ /* increment index element curent coada */

void InitCoada (ACoada pc){

int CoadaGoala (ACoada pc){

int CoadaPlina (ACoada pc){

void AdaugElC (ACoada pc, ElTip el){

ElTip ScotElC (ACoada pc){

ElTip CapCoada (ACoada pc){

void AfisareCoadaV (ACoada pc){

void Afisare_Poz_Prim_Ultim (ACoada pc){

void main (void){

/* coadvcuv.c - programul construieste o coada de cuvinte,

struct st_cuvant * atasare_coada (struct st_cuvant *ultim, char *sirc)

void extragere ( struct st_cuvant * primu)

/* listcirc.c - programul construieste o lista circulara de caractere,

void afis_list_circ (struct st_litera *plc){

int numar_aparitii_car (struct st_litera *start, char *pcar)

/* listord.c - construiete o lista ordonata de numere intregi, distincte */

void afisare (struct st_cuvant * curent)

/* listrecc.cpp - programul construieste o lista de cuvinte,

void afisare (struct st_cuvant * curent)

/* stivacar.c - programul construieste o stiva de caractere, pe care apoi o tipareste */

/* stivatab.c - operatii cu o stiva realizata static intr-un tablou;

typedef int ElTip; // ElTip - definire tip element din stiva

void eroare (char *meserr){

void InitStiva (AStiva rs){

int StivaGoala (AStiva rs){

int StivaPlina (AStiva rs){

void Push (AStiva rs, ElTip el){

ElTip Pop (AStiva rs){

ElTip CapStiva (AStiva rs){

void AfisareStiva (AStiva rs){

void Afisare_Poz_sp (AStiva rs){

void find_replace(nod cap,char cuvant1,char *cuvant2)

void free_mem(nod cap,stiva undo,stiva *redo)

struct st_cuvant * atasare_coada (struct st_cuvant ultim, char sirc)

int numar_aparitii_car (struct st_litera start, char pcar)

void citire_graf (int a[DIMN+1][DIMN+1], int pn, int pm){