Dosar Probleme Fara Comentarii

#include <stdio.
h>
#include <stdlib.h>
#include <conio.h>
typedef struct tnod
{
int
nr;
int
ap;
struct tnod *pstg;

struct tnod *pdr;
} ARB;
int nel = 0;
ARB *e;
void inserare (ARB * &v, int val){

ARB *pc;
int gasit;
if (!v)
{v = new ARB; v->nr=val; v->ap=1;
v->pstg=NULL; v->pdr=NULL;}
else if (v->nr > val)
inserare(v->pstg, val);
else if (v->nr < val)
inserare(v->pdr, val);
else
v->ap++;
}
void inlocuire_nod(ARB * &n){ // n - nodul de eliminat
if (n->pdr)
inlocuire_nod(n->pdr);
else
{e->nr=n->nr;
// e - nodul care se elimina (continutul sau)
e->ap=n->ap;
// se actualizeaza valorile lui 'e' cu maximul din
e=n;
// arborele nodului 'n' , ramura dreapta
n=n->pstg; // pastrez legatura la ramura stanga a nodului

free(e);
// pentru care elimin ramura dreapta, a carei
// valori s-au mutat in nodul 'eliminat' (inlocuit)
void elimina_nod (ARB * &a, int x){// a-arbore, x-valoarea de eliminat

if (!a)
printf("\nCheia cautata %d nu este in arbore!\n", x);
else if (x < a->nr)
elimina_nod (a->pstg, x);
else if (x > a->nr)

elimina_nod (a->pdr, x);
else
// s-a gasit pozitia lui 'x'

{e=a;
if (!a->pstg){
a=a->pdr;
free(e);
}
else if (!a->pdr){
a=a->pstg;
free(e);
}
else
inlocuire_nod(a->pstg);
}
}
void listare_SRD (ARB *v){

if (v)
{if (v->pstg)
listare_SRD (v->pstg);
printf("%3d(%d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pdr)
listare_SRD(v->pdr);
}
}
main()
{
ARB *pl;
int valoare;
pl = NULL;
clrscr();
printf("Se construieste un arbore de cautare si permite elimarea unui nod.\n");
printf ("\nIntroduceti un sir de valori, terminat cu EOF.\n");
printf ("Valoare:");
while ( scanf ("%d", &valoare) != EOF) {
inserare (pl,valoare);
}
/* afisare arbore */
printf("\nListare arbore SRD:\n");
listare_SRD (pl);
printf ("NULL\n");
printf("\nValoare de eliminat: ");
scanf("%d", &valoare);
elimina_nod(pl, valoare);
printf("\nListare arbore SRD, dupa eliminarea valorii %d:\n", valoare);

nel=0;
listare_SRD (pl);
printf ("NULL\n");
printf("Terminare dupa apasarea unei taste!\n");
getch();
}
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct tnod
{
int
nr;
int
ap;
struct tnod *pstg;

struct tnod *pdr;
} ARB;
int nel = 0;

ARB *pc;
int gasit;
if (!v)
else
v->ap++;
}

if (v)
{if (v->pstg)
printf("%3d(%2d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pdr)
}
}
int maxim (int a, int b){

if (a>b)
return a;
return b;
}
int inaltime (ARB *v){

if (!v)
return 0;
else
return 1+maxim(inaltime(v->pstg), inaltime(v->pdr));
}
main()
{
ARB *pl;
int valoare;
pl = NULL;
clrscr();
printf("Dimensiune structura: %d\n", sizeof (struct tnod));
printf ("\nIntroduceti un sir de valori, terminat cu 0.\n");
while ( scanf ("%d", &valoare) != EOF) {

}
/* afisare arbore */
printf("\nListare arbore SRD:\n");
listare_SRD (pl);
printf ("NULL\n");
printf("Inaltime arbore: %d\n", inaltime(pl));
}
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct tnod
{
int
nr;
int
ap;
struct tnod *pstg;

struct tnod *pdr;
} ARB;
int nel = 0;

ARB *pc;
int gasit;
if (!v)
else
v->ap++;
}
void listare_RSD (ARB *v){
if (v)
{printf("%3d(%2d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pstg)
listare_RSD (v->pstg);
if (v->pdr)
listare_RSD(v->pdr);
}
}
if (v)
{if (v->pstg)
printf("%3d(%2d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pdr)
}
}
main()
{
ARB *pl;
int valoare;
pl = NULL;
clrscr();
printf("Dimensiune structura: %d\n", sizeof (struct tnod));
printf ("\nIntroduceti un sir de valori, terminat cu 0.\n");
scanf ("%d", &valoare);
while ( valoare ) {
}
listare_RSD (pl);
printf ("NULL\n");
nel=0;
printf("\nListare SRD:\n");
listare_SRD (pl);
printf ("NULL\n");
}
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define LUNGMAX 20
struct st_arbore
{
char *cuvant;
int nrap;
struct st_arbore *st, *dr;
};
int nle=0;
void actualizare (struct st_arbore * arb , char *cuv){
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)
{
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();
}
tiparire_arbore (arbo->dr) ;
}
}
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)) ;
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);
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMCV 25
struct st_cuvant
{
char
*cuvant;
struct st_cuvant *urmator;

};
int ncl=0;
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)
{
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;
printf (" %s -> ", primu->cuvant);
ncl++;
if (ncl%5==0)
printf("\n");
primu=primu->urmator;
free(ptr);
}
printf ("NULL\n");
}
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;
gets(cuv);
while (strcmp(cuv, SIR_VID))

{
if(!(ultimul=atasare_coada (ultimul, cuv)))
break;
gets(cuv);}
extragere (primul);
}
#include <stdio.h>
#include <conio.h>
#define MaxC
10
typedef int ElTip;

typedef
struct {
ElTip elem [MaxC];// spatiu pentru elem. cozii
int
prim, ultim;
} TCoada, *ACoada;
void eroare (char *meserr){
printf("%s\n", meserr);
}
int IncIndexC (int i){

return ((i+1) % MaxC);
}
void InitCoada (ACoada pc){
pc->prim=0;
pc->ultim=MaxC-1;
}
int CoadaGoala (ACoada pc){
return (IncIndexC (pc->ultim) == pc->prim);

}
int CoadaPlina (ACoada pc){
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){
{eroare ("Coada Goala !!!");
return 0;
}
else
return pc->elem[pc->prim];
}
void AfisareCoada (ACoada pc){
TCoada c=*pc;
ACoada pt=&c;
int nvl=0;
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;
}
}
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
eroare("Coada Goala !!!\n");
break;
case 'a':
case 'A':AfisareCoada (pc);
break;
case 'p':
case 'P': Afisare_Poz_Prim_Ultim (pc);
break;
}
printf("\nOptiuni Int, Ext, Afis coada, Cap coada, Poz p/u, Stop: ");
gets(optiune);
}
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMCV 25
struct st_cuvant
{
char
*cuvant;

};
int ncl=0;
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)
{
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;
printf (" %s -> ", primu->cuvant);

ncl++;
if (ncl%5==0)
printf("\n");
primu=primu->urmator;
free(ptr);
}
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);
}
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct s_stiva
{
int
valoare;
int nr_aparitii;
struct s_stiva *urmator;
};
struct s_stiva *adauga_stiva (struct s_stiva *ultimul, int val)

{
struct s_stiva
*ptr_stiva;
if (ultimul==NULL)
{
ultimul=(struct s_stiva *) malloc(sizeof(struct s_stiva));
if (ultimul==NULL)
{printf("Memorie plina!\n");
return(NULL);
}
else
{
ultimul->valoare=val;
ultimul->nr_aparitii=1;
ultimul->urmator=NULL;
return(ultimul);
}
}
else
{
ptr_stiva=ultimul;
while(ptr_stiva->valoare!=val && ptr_stiva->urmator!=NULL)
ptr_stiva=ptr_stiva->urmator;
if(ptr_stiva->valoare==val)
{ptr_stiva->nr_aparitii++;
return(ultimul);
}
else
{ptr_stiva=(struct s_stiva *)malloc(sizeof(struct s_stiva));
if (ptr_stiva==NULL)
{printf("Mmeorie plina!\n");
return(NULL);
}
else
{ptr_stiva->valoare=val;
ptr_stiva->nr_aparitii=1;
ptr_stiva->urmator=ultimul;
return(ptr_stiva);
}
}
}
}
void afisare_stiva(struct s_stiva *ultim)

{
int nr_val_linie = 0;
while (ultim!=NULL)
{
printf("%2d(%d)-> ", ultim->valoare, ultim->nr_aparitii);
ultim=ultim->urmator;
nr_val_linie++; /* contor pentru nr. de valori afisate pe linie */
if (nr_val_linie%8==0)
printf("\n");
}
printf ("\n");
}
void eliberare_spatiu (struct s_stiva *ptrs){

struct s_stiva *p=ptrs;
while(p){ptrs=p;
p=p->urmator;
free(ptrs);
}
}
void main()
{
struct s_stiva *ultim=NULL;
int numar;
clrscr();
printf("Prg. construieste si afiseaza o stiva de nr. intregi, distincte.\n");
printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");

printf("Introduceti numar: ");
while(scanf("%d", &numar)!=EOF)
{if((ultim=adauga_stiva(ultim, numar))==NULL)
break;
}
afisare_stiva(ultim);
eliberare_spatiu(ultim);
}
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct s_coada
{
int
valoare;
struct s_coada *urmator;

};
int nr_val_linie=0;
void adaug_coada (struct s_coada *primul, int val)
if (primul->urmator==NULL){
primul->urmator=(struct s_coada *)malloc(sizeof(struct s_coada));
if(!primul->urmator)
{printf("Memorie plina!!!\n");
exit(1);
}
primul=primul->urmator;
primul->valoare=val;
}
else
adaug_coada(primul->urmator, val);
}
void afisez_coada(struct s_coada *primul)

{
if (primul)
{
printf("%2d-> ", primul->valoare);
nr_val_linie++;
if (nr_val_linie%8==0)
printf("\n");
afisez_coada(primul->urmator);
}
}
void eliberare_spatiu (struct s_coada *ptrs){

struct s_coada *p=ptrs;
if(p){ ptrs=p;
p=p->urmator;
free(ptrs);
eliberare_spatiu(p);
}
}
void main()
{
struct s_coada *prim=NULL;
int numar;
clrscr();
printf("Prg. construieste si afiseaza o coada de nr. intregi, distincte.\n");
printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");
scanf("%d", &numar);
prim=(struct s_coada *)malloc(sizeof(struct s_coada));
if(!prim)
{printf("Memorie plina!!!\n");
exit(1);
}
prim->valoare=numar;
prim->urmator=NULL;
while(scanf("%d", &numar)!=EOF)
{adaug_coada(prim, numar);
}
afisez_coada(prim);
printf("NULL\n");
eliberare_spatiu(prim);
}
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct s_arbore
{
int
valoare;
int nr_ap;
struct s_arbore *stg;
struct s_arbore *dr;
};
int maxy = 1;
struct s_arbore *constr_arbore (void)

{
struct s_arbore *pelem, * parb;
int
numar, gasit_poz_ins;
parb = NULL;
printf ("Valorile intregi de introdus in arbore:\n");
printf ("Valoare = ");
scanf ("%d", &numar);
while (numar)
{
if (parb == NULL)
{
parb = (struct s_arbore *) malloc(sizeof(struct s_arbore));
parb -> valoare = numar;
parb -> nr_ap = 1;
parb -> stg = NULL;
parb -> dr = NULL;
}
else
{gasit_poz_ins = 0;
pelem = parb;
while (pelem != NULL && !gasit_poz_ins)
if (numar == pelem->valoare)
{pelem->nr_ap++; break;}
else if(numar < pelem->valoare)
if (pelem->stg)
pelem = pelem->stg;
else
{gasit_poz_ins = 1;
pelem->stg=(struct s_arbore *)
malloc (sizeof(struct s_arbore));
pelem = pelem->stg;
}
else
if (pelem->dr)
pelem = pelem->dr;
else
{gasit_poz_ins = 1;
pelem->dr=(struct s_arbore *)
pelem = pelem->dr;
}
if (pelem == NULL)
exit(0);
if (gasit_poz_ins)
{pelem->valoare = numar;
pelem->nr_ap = 1;
pelem-> stg = NULL;
pelem-> dr = NULL;
}
}
printf ("Valoare = ");
}
return ( parb );
}
void display_arbore (struct s_arbore *start, int pas, int p_x, int p_y)
{
if ( start != NULL )
{
display_arbore (start->stg, pas/2, p_x-pas/2, p_y+2);
gotoxy (p_x, p_y);
printf ("(%d,%d)", start->valoare, start->nr_ap);
gotoxy (wherex()-7, p_y+1);
printf("/
\\");
if (wherey() > maxy)

maxy = wherey();
display_arbore (start->dr, pas/2, p_x+pas/2, p_y+2);
}
}
struct s_arbore *caut_val (struct s_arbore *p_arb, int numar_cautat,

int *p_nivel)
{
while (p_arb != NULL)
{
(*p_nivel)++;
if (p_arb ->valoare == numar_cautat)
return (p_arb);
else if (numar_cautat < p_arb->valoare)
p_arb = p_arb->stg;
else
p_arb = p_arb->dr;
}
return (0);
};
int maxim (int a, int b) {

if (a > b)
return (a);
return (b);
}
int inalt (s_arbore *parb){
int l;
if (parb == NULL)
l = 0;
else
l = maxim(inalt(parb->stg), inalt(parb->dr)) + 1;
return l;
}
int minim (int a, int b) {

if (a < b)
return (a);
return (b);
}
int inalt_min (s_arbore *parb){

int i;
if (parb == NULL)
i=0;
else
i= minim(inalt_min(parb->stg), inalt_min(parb->dr)) + 1;
return i;
}
void main (void)

{
struct s_arbore *constr_arbore();
void display_arbore (struct s_arbore *start, int p_niv, int p_x, int p_y);
struct s_arbore *caut_val (struct s_arbore *p_arb, int numar_cautat,
int *p_pozitie);
struct s_arbore *start_arb, * ptr_valoare;
int *nivel, val_cautata, niv, x, y;
char *pcuv;
clrscr();
start_arb = constr_arbore();
niv = 40; x = 37; y = 1;
printf("Pentru afisare arbore apasati o tasta.\n");
getch();
clrscr();
display_arbore (start_arb, niv, x, y);
if ( start_arb == NULL )
printf ("Arbore vid de valori.\n");
else
{
gotoxy(1,maxy+1);
pcuv = "";
printf("inalt = %d, inalt_min = %d\n", inalt(start_arb), inalt_min(start_arb));
if (inalt(start_arb)-inalt_min(start_arb) > 1)
pcuv = "nu";
printf("Arborele %s este echilibrat.\n", pcuv);
printf ("Valoarea de cautat in arbore :");
scanf ("%d", &val_cautata);
*nivel = 0;
ptr_valoare = caut_val(start_arb, val_cautata, nivel);

if (ptr_valoare != NULL)
printf ("Valoarea: %d, este in arbore pe nivelul: %d\n",
ptr_valoare -> valoare, *nivel);
else
printf ("Valoarea %d nu este in arbore.\n", val_cautata);
}
printf("Apasati o tasta pentru a termina programul.\n");
getch();
}
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define DIM_MAX 100
struct s_arbore
{
int
valoare;
int nr_ap;
struct s_arbore *stg;
struct s_arbore *dr;
};
int maxy = 1;
int nr_nod[10], niv=0, max_niv=0;
int nr_frunze=0;
struct s_arbore *constr_arbore (void)

{
struct s_arbore *pelem, * parb;
int
numar, gasit_poz_ins, ind=1;
parb = NULL;
printf ("Valorile intregi de introdus in arbore:\n");
printf ("Valoare(%d)= ", ind++);
while (numar)
{
if (parb == NULL)
{
parb = (struct s_arbore *) malloc(sizeof(struct s_arbore));
parb -> valoare = numar;
parb -> nr_ap = 1;
parb -> stg = NULL;

parb -> dr = NULL;
}
else
{gasit_poz_ins = 0;
pelem = parb;
while (pelem != NULL && !gasit_poz_ins)
if (numar == pelem->valoare)
{pelem->nr_ap++; break;}
else if(numar < pelem->valoare)
if (pelem->stg)
pelem = pelem->stg;
else
{gasit_poz_ins = 1;
pelem->stg=(struct s_arbore *)
pelem = pelem->stg;
}
else
if (pelem->dr)
pelem = pelem->dr;
else
{gasit_poz_ins = 1;
pelem->dr=(struct s_arbore *)
pelem = pelem->dr;
}
if (pelem == NULL)/* daca nu mai e spatiu -> exit */
exit(0);
if (gasit_poz_ins)
{pelem->valoare = numar;
pelem->nr_ap = 1;
pelem-> stg = NULL;
pelem-> dr = NULL;
}
}
printf ("Valoare(%d)= ", ind++);
}
return ( parb );
}
void display_arbore (struct s_arbore *start, int pas, int p_x, int p_y)
{int p;
if ( start != NULL )
{p=p_x-pas/2;
if (p<1)
p=1;
display_arbore (start->stg, pas/2, p, p_y+2);
gotoxy (p_x, p_y);
printf ("(%d,%d)", start->valoare, start->nr_ap);
p=wherex()-7;
if (p<1)
p=1;
gotoxy (p, p_y+1);
printf("/
\\");
if (wherey() > maxy)

maxy = wherey();
p=p_x+pas/2;
if (p>73)
p=73;
display_arbore (start->dr, pas/2, p, p_y+2);
}
}
int nr_nod_arb (struct s_arbore *a) {
int nr_nod;
if (a==NULL)
nr_nod = 0;
else
nr_nod = nr_nod_arb(a->stg) + nr_nod_arb(a->dr) + 1;
return (nr_nod);
}
void nr_frunze_arb (struct s_arbore *a) {
if (a) {
if (!(a->stg) && !(a->dr))

{nr_frunze++;
printf(" %d ", a->valoare);}
nr_frunze_arb(a->stg);
nr_frunze_arb(a->dr);
}
}
void max_nod (struct s_arbore *a){

if (a)
{niv++;
max_niv=niv;
nr_nod[niv]++;
if (a->stg){
max_nod(a->stg);
niv--;}
if (a->dr){
max_nod(a->dr);
niv--;}
}
}
void main (void)

{
struct s_arbore *arb;
int dim, x, y, i, max_noduri=0, i_max=0;
for (i=0;i<10;i++)
nr_nod[i]=0;
clrscr();
arb = constr_arbore();
dim = 40; x = 37; y = 1;
printf("Pentru afisarea primului arbore apasati o tasta.\n");
getch();
clrscr();
display_arbore (arb, dim, x, y);
gotoxy(1, maxy+1);
printf("Numarare de noduri din arbore. Apasati o tasta!\n");
getch();
printf("\nNmuar de noduri: %d\n", nr_nod_arb(arb));
printf("Frunzele din arbore sunt :\n\t");
nr_frunze_arb(arb);
printf("\nNmuar de frunze: %d\n", nr_frunze);
max_nod(arb);
for (i=0; i<=max_niv; i++)
if (max_noduri<nr_nod[i])
{i_max = i;
max_noduri=nr_nod[i];
}
printf("Nivelul %d contine numarul maxim de noduri (frunze) %d\n",
i_max,nr_nod[i_max]);
printf("\nApasati o tasta pentru a termina programul!!!!\n");
getch();
#include <stdio.h>
struct st_litera
{
char
car;
struct st_litera * pred, *urm;

};
int ncl=0;
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)
{
printf("Memorie plina !!!!!!\n");
break;
vr->car=c;
if(pl->pred==pl)
{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;
while (p != plc)
{printf("%c -> ", p->car);
p=p->urm;
ncl++;
if (ncl%10==0)
printf("\n");
}
if (plc->urm!=plc)
printf("%c (primul).\n", plc->urm->car);
else
printf("NULL");
}
int numar_aparitii_car (struct st_litera *start, char *pcar)

{
int
numar = 0;
struct st_litera *curent;

*pcar=start->car;
curent=start->urm;
while (curent != start)
if (start->car == curent->car)
numar++;
curent=curent->urm;
}
return (numar);
}
void main()
{
struct st_litera *primul;

char ch;
primul->urm=primul->pred=primul;
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;
printf("\nCaracterul \'%c\' este in lista de %d ori\n",
ch, numar_aparitii_car(primul, &ch));
}
#include <stdio.h>
#include <stdlib.h>
struct tnod
{
int
valoare;
struct tnod *urmator;
};
void adaugare (tnod * &v, int val){

tnod *sf;
if (!v)
{v = new tnod; v->valoare=val; v->urmator=NULL;}
else
adaugare (v->urmator, val);
}
void listare (tnod *v){

if (v)
{printf("%d->", v->valoare);
listare (v->urmator);
}
}
main()
{
struct tnod *pl;
int valoare;
pl = NULL;
printf ("Introduceti un sir de valori, terminat cu 0.\n");
while ( valoare ) {
adaugare (pl,valoare);
}
listare (pl);
printf ("NULL\n");
}
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct st_numar {
int numar;
struct st_numar *next;
};
int nvl=0;
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);
prim->next=NULL;
while (scanf("%d", &nr)==1){
prim=inserare (prim, nr);
}
printf("\nLista de numere ordonata este:\n");

while (prim)
{vr=prim;
printf("%d -> ", vr->numar);
nvl++;
if (nvl%8==0)
printf("\n");
prim=prim->next;
free(vr);
}
printf("NULL\n");
}
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;
curent=primul;
while (curent != NULL && vr->numar > curent->numar)
{
anterior=curent;
curent=curent->next;
}
if(vr->numar == curent->numar)
{free(vr);
return (primul);
}
vr->next=curent;
if (anterior == NULL)
primul=vr;
else
anterior->next=vr;
return (primul);
}
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMC 25
int nvl=0;
struct st_cuvant
{
char
*cuvant;
};
int atasare (struct st_cuvant * vr)
{
char cuv[DIMC], *pc;

if (vr->urmator==NULL)
{
vr->urmator=(struct st_cuvant *)malloc(sizeof(struct st_cuvant));
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
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;
char c[DIMC];
clrscr();
" tastatura\n");
gets(c);
primul->cuvant=strdup(c);
while (atasare(primul));
afisare (primul);
printf("NULL\n");
}
#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];

};
int atasare (struct st_cuvant * vr)
{
char cuvcit[DIMC];
{
vr->urmator=(struct st_cuvant *)malloc(sizeof(struct st_cuvant));
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
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;
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");
}
#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)
{
printf("Memorie plina !!!!!!\n"); /* se tipareste un

mesaj de eroare */
break;
}
vr->car=c;
vr->urmator=primul;
primul=vr;
}
vr=primul;
while (vr != NULL)

{
printf("%c -> ", vr->car);
vr=vr->urmator;
}
printf(" NULL");
#include <stdio.h>
#include <conio.h>
#define MaxS
10
typedef int ElTip;

typedef
struct {
ElTip elem [MaxS];
int
sp;
} TStiva, *AStiva;

}
void InitStiva (AStiva rs){
rs->sp=-1;
}
int StivaGoala (AStiva rs){

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

}
void Push (AStiva rs, ElTip el){
if (StivaPlina (rs))
eroare ("Stiva Plina !!!");
else
{rs->sp=rs->sp+1;
rs->elem[rs->sp]=el;
}
ElTip Pop (AStiva rs){
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){
TStiva s=*rs;
AStiva pt=&s;
int nvl=0;
if (pt->sp == -1)
eroare("Stiva Goala !!!\n");
else
while (!StivaGoala (pt))

{printf ("%d -> ", CapStiva (pt));
Pop (pt);
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);
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':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);
}
}
#include <stdio.h>
#include <conio.h>
#define MaxS
10
typedef int ElTip;

typedef
struct {
ElTip elem [MaxS];// spatiu pentru elem. stivei
int
sp;
} TStiva, *AStiva;

}
void InitStiva (AStiva rs){
rs->sp=-1;
}
int StivaGoala (AStiva rs){

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

}
void Push (AStiva rs, ElTip el){
if (StivaPlina (rs))
eroare ("Stiva Plina !!!");
else
{rs->sp=rs->sp+1;
rs->elem[rs->sp]=el;
}
ElTip Pop (AStiva rs){
ElTip e;
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 AfisareStivaV (AStiva rs){
int psl=rs->sp;
int nvl=0;
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);
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':
case 'P': Afisare_Poz_sp (rs);
break;
}
printf("\nOptiuni Int, Ext, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
}
}
#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)
{
printf("Memorie plina !!!!!!\n");
break;
}
vr->car=c;
vr->urmator=primul;
primul=vr;
}
vr=primul;
while (vr != NULL)

{
printf("%c -> ", vr->car);
vr=vr->urmator;
}
printf(" NULL");
int distinct (struct st_lista *prim, char ch)

{
struct st_lista *ptr;
int gasit;
ptr=prim;
gasit=0;
while (ptr != NULL && !gasit)
{
gasit=(ptr->car == ch);
ptr=ptr->urmator;
}
return (!gasit);
}
#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];
while (j<=r){
if (j<r)
if (a[j]<a[j+1])
j++;
if (x>a[j])
goto gata;
a[i]=a[j];
i=j; j=2*i;
}
gata: a[i]=x;
}
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]);
}
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();
}
#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];
while (j<=r){
if (j<r)
if (a[j]>a[j+1])
j++;
if (x<a[j])
goto gata;
a[i]=a[j];
i=j; j=2*i;
}
gata: a[i]=x;
}
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 ){
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();
printf ("Numarul de elemente: ");
scanf ("%d",&ne);
for ( i = 1 ; i <= ne ; ++i)
{
printf (" sir(%d)=", i);

scanf ("%lf", &sir[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");
getch();
}
#include<stdio.h>
#include <conio.h>
int ncomp=0, nins=0;
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;
while (s <= d)
{ncomp++;
m=(s+d)/2;
if (x < a[m])
d=m-1;
else
s=m+1;
}
for (j=i-1; j>=s; --j, nins++)
a[j+1]=a[j];
a[s]=x;
}
}
void main(void){
double sir[100]; int ne,i;
clrscr();
printf("Numar elemente:");
scanf("%d", &ne);
for(i=0; i<ne; i++)
{
printf("sir(%d)= ", i+1);
scanf("%lf", &sir[i]);
}
printf("Sirul ordonat este: \n");
sort_ins_binara(sir , ne);
for (i=0;i<ne;i++)
{
printf(" sir (%2d) = %lf \n", i+1, sir[i]);
if ((ne+1)%4==0)
printf("\n");
}
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d deplasari\n",
ncomp, nins);}
#include <stdio.h>
#include <conio.h>
int ncomp=0, nins=0;
void sort_ins_direct (double a[], int n)

{
double x;
int i, j;
for (i=1; i<n; ++i)
{
x=a[i];
j=i-1;
while (x < a[j] && j >= 0)
{
a[j+1]=a[j];
j--;
ncomp++; nins++;
}
a[j+1]=x;
}
}
void main()
{
double sir[100];
int ne, i;
clrscr();
scanf("%d", &ne);
for(i=0; i<ne; i++)
{
printf("sir(%d)= ", i+1);
}
sort_ins_direct (sir, ne);
printf("\n Sirul ordonat:\n");
for(i=0; i<ne; i++)
{
printf(" sir(%d)=%5.2lf ", i+1, sir[i]);
if ( (i+1) %5 == 0 )
printf("\n");
}
printf("\n");
ncomp, nins);}
#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;
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));
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);
}
void scrie_vector(int vect[], int d){

int i;
for (i=0; i<d; i++)
printf("%5d,", vect[i]);
}
void main()
{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();
}
#include<stdio.h>
#include<conio.h>
#define DIM 100
typedef int VECTOR[DIM];

int ncomp=0, ninv=0;
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)

{int s, d, i, j, is, x, t;
struct st_stiva {int s, d;};
struct st_stiva stiva[DIM];
is=1; stiva[is].s=0; stiva[is].d=n-1; d=n-1;
do{
s=stiva[is].s; d=stiva[is].d; is--;
do
{i=s; j=d;
x=a[(s+d)/2];
do
{
while (a[i]<x) i++, ncomp++;
while (a[j]>x) j--, ncomp++;
if (i<=j)
{t=a[i];
a[i]=a[j];
a[j]=t;
i++; j--;
ninv++;
}
} while(i<=j);
if (i<d){
is++;
stiva[is].s=i;
stiva[is].d=d;
}
d=j;
} while (s<d);
}while (is>0);
}
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();
}
#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);
}

{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();
}
#include<stdio.h>
#include <conio.h>
void sort_sel_direct ( double a[], int n )
{
double x;
int i, j, k;
for ( i = 0 ; i < n-1 ; ++i )
{
k = i;
x = a[i];
for ( j = i+1 ; j < n ; ++j, ncomp++ )
if (a[j] < x)
{
k = j;
x = a[k];
}
a[k] = a[i];
a[i] = x;
ninv++;
}}
void main()
{
double sir[100];
int ne,i, nl=0;
clrscr();
scanf("%d",&ne);
for(i=0;i<ne;i++)
{
printf("sir(%d)=",i+1);
scanf("%lf",& sir[i]);
}
sort_sel_direct(sir,ne);
for(i=0;i<ne;i++)
printf(" sir(%2d)=%5.1lf",i+1,sir[i]);
nl++;
if ( nl % 5 == 0 )
printf("\n"); }
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d inversiuni\n",

ncomp, ninv);
}
#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;
do
{for (i=s; i<=d; i++, ncomp++)
if (v[i] > v[i+1])
{t=v[i];
v[i]=v[i+1];
v[i+1]=t;
k=i;
ninv++;}
d=k-1;
for (i=d; i>=s; i--, ncomp++)
if (v[i+1] < v[i])
{t=v[i];
v[i]=v[i+1];
v[i+1]=t;
k=i;
ninv++;}
s=k+1;
}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();
}
#include <stdio.h>
#include <conio.h>
void sort_met_bulelor (double a[], int n)
{double x;
int i, j;
for (i=1; i<n; i++)
for (j=n-1; j>=i; j--, ncomp++)
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++)
{printf("sir(%d)=",i+1);
}
sort_met_bulelor (sir, ne);
for(i=0; i<ne; i++)
{
printf("sir(%2d)=%5.1lf ", i+1, sir[i]);
nl++;
if (nl % 5 == 0)
printf("\n");
}
printf("\n");
ncomp, ninv);
}
#include <stdio.h>
#define DIM 100
#include <conio.h>
struct tip_struct
{
char
nume_prenum [DIM];
float
medie;
};
void main(void)
{
struct tip_struct stud [100];
int
ind[100];
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++)
{
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');
}
ind[i] = i;
ShakerSort (stud, ind, ns);
printf("Lista ordonata cu numele / prenumele si media studentilor\n");
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];
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);
#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++;
}
}
} 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();
}
#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++){
for (j=i+1; j<n; j++)
{
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();
}
#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},
};
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++;
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)
{printf("\n");
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)
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);

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]);
iesire(0, i, j, L, d);
printf("\nNumar total de solutii: %i\n", nr_sol);
printf("Apasati ENTER pentru a termina programul !");
getch();
}
#include <stdio.h>
#include <conio.h>
#define N 10
#define M 15
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;
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);
}
}
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])
}
*/

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;
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){
printf("\n\tObiect %d: (%d,%d)\n", nr_ob+1, il, ic);
obiect(il, ic, F);
nr_ob++;
}
}while (il<n+1 || ic<m+1);
printf("\n\tNumar obiecte: %i\n", nr_ob);
printf("\nApasati ENTER pentru a termina programul !");
getch();
}
#include <stdio.h>
#include <conio.h>
#define NR_MAX 3
int a[NR_MAX][NR_MAX];
int nl, nc, l, c;
int ntotsol=0;
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();
{
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;
};
if (incearca(0))
ntotsol++;
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();
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];
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>
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
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();
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;
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
{
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();
}
// sudoku1s.cpp - program pentru "acoperirea" unui careu de 81 casute (9*9)

// din care o parte sunt fixate, dupa urmatoarea regula:
// orice linie, coloana sau patrat de 3*3 casute sa contina o singura data
// fiecare cifra cuprinsa intre 1 si 9. Verificarea incrucisata a liniilor
// coloanelor si patratelor mici de 3*3 ofera indicii pentru gasirea solutiei
// se determina si afiseaza prima solutie gasita
#include <stdio.h>
#include <conio.h>
#define N 9
#define NSQ N*N
// N - dimensiunea careului de joc; NSQ=N^2;
int q;
long int nr_incercari;
int si[N][N]={
{8,0,3,0,0,9,1,0,0},
{0,0,9,0,0,1,0,0,0},
{6,0,0,0,4,0,0,0,8},
{0,0,0,6,0,7,0,5,0},
{3,0,6,0,0,0,2,0,9},
{0,7,0,9,0,3,0,0,0},
{5,0,0,0,7,0,0,0,2},
{0,0,0,1,0,0,7,0,0},
{0,0,1,4,0,0,8,0,3}
};
int s[N][N];
int vp[NSQ][N+1]; // matricea de valori permise pentru fiecare casuta
// din careu, construita in concordanta cu regulile jocului
// matricea are o coloana in plus (N+1), care este de fapt
// prima (0) si in care vom pune -1 pentru casutele ce au
// valori impuse (sau pentru cele care nu mai au decat o
// singura alegere, pentru a reduce numarul de incercari
void init_joc(){
int i, j, l, c, il, ic, nr1;
clrscr();
printf("\nInitializare careu de joc:\n");

/*for (i=0; i<N; i++){
// initializare careu de joc
printf("Valorile pentru linia %d (separate prin spatii): ", i+1);

for (j=0; j<N; j++)
scanf("%d", &si[i][j]);
}
clrscr();*/
for (i=0; i<N; i++)
{for (j=0; j<N; j++)
printf("%4d", si[i][j]);
printf("\n");
}
for (i=0; i<NSQ; i++)
// i-casuta pentru care determin valorile posibile
{vp[i][0]=0; // pozitia curenta (initiala) in cadrul vectorului i

for (j=1; j<=N; j++)
vp[i][j]=1; // initial sunt permise toate valorile (1-9)
l=i/N; c=i%N;
// linia si coloana elementului 'i' din careul 9*9
if (si[l][c]==0) // daca casuta nu are valoare initiala

{
// se cauta valorile 'impuse' pe coloana respectiva
for (il=0; il<N; il++) // si pentru acestea (diferite de 0)

if (si[il][c]) // se elimina din lista de valori
vp[i][si[il][c]]=0; // posibile casutei resp.
for (ic=0; ic<N; ic++) // se repeta aceeasi operatie si
if (si[l][ic]) // pentru linia respectiva
vp[i][si[l][ic]]=0;
l=(i/N/3)*3; c=(i%N/3)*3;// l si c elem 'i' din careul 3*3
for (il=l; il<l+3; il++) // se aplica aceeasi regula si

for (ic=c; ic<c+3; ic++) // pentru careul 3*3 in care
if (si[il][ic]) // se afla casuta i, (l,c)
vp[i][si[il][ic]]=0; // elimina val
} // valorile eliminate sunt cele reprezentate de indicii
// pentru care in matrice punem 0; 1 - indici=val permise
else
// daca casuta are valoare initiala, atunci pun 0 peste tot

{for (ic=1; ic<=N; ic++) // cu exceptia casutei cu val impusa
vp[i][ic]=0; // si pun -1 in prima coloana (0)
vp[i][0]=-1; // pozitii ce contin valori initiale
vp[i][si[l][c]]=1;
}
nr1=0;// verific daca pentru pozitia i, exista doar 1 nr posibil

for (j=1; j<=N; j++) // pentru a pune in prima coloana (0) din vp
if (vp[i][j]) // valoarea -1, care specifica ca nu avem
nr1++; // decat o singura solutie (alegere)
if (nr1==1)
vp[i][0]=-1;
}
for (i=0; i<N; i++) // se transfera matricea initiala in matricea finala
for (j=0; j<N; j++) // cea care va contine solutia jocului
s[i][j]=si[i][j];
/* clrscr();
// afisarea matricii de valori permise pentru fiecare casuta
printf("Matricea numerelor permise pentru fiecare pozitie din careu:\n");

for (i=0; i<NSQ; i++){
if (i%18==0) // se continua afisarea dupa un numar de linii afisate
{printf("\nContinua afisarea dupa apasarea unei taste\n");

getch();
clrscr();
}
printf("Pozitia [%d,%d] : ", i/N+1, i%N+1);
printf("% d ", vp[i][0]);
for (j=1; j<=N; j++)
if (vp[i][j])
printf("%d ", j);
else
printf("%d ", 0);
printf("\n");
} */
}
int valid(int ip, int k){// fct verifica daca valoarea k poate fi pe poz ip
int l, c, i, j;
l=ip/N; c=ip%N;
// linia 'l' si coloana 'c' a elementului 'ip' din careul 9*9
for (i=0; i<N; i++) // daca valoarea exista pe coloana respectiva (c)
if (k==s[i][c]) // nu mai poate fi incercata (valida) pentru casuta
return 0; // curenta (ip) si returneaza invalid (0)
for (j=0; j<N; j++) // aceeasi conditie se testeaza si pentru linia 'l'
if (k==s[l][j])
return 0; // valoarea k nu poate fi pusa in casuta 'ip'
l=(ip/N/3)*3; c=(ip%N/3)*3;// l si c elem 'ip' din careul 3*3 corespunzator
// in care este inclusa casuta 'ip', deci 'l' si 'c'
// reprezinta coord. stanga-sus al careului 3*3

for (i=l; i<l+3; i++) // se verifica conditia de validitate si pentru careul
for (j=c; j<c+3; j++) // 3*3 in care se afla casuta 'ip'
if(k==s[i][j])
return 0;
return 1; // daca toate conditiile (linie/coloana/careu 3*3) sunt
}
// indeplinite, functia returneaza 1 (valoare valida)
void incearca (int i, int *pq){// determina valoarea urmatoare

int k, x, y, q1=0;
// pentru casuta 'i'
k = 0;
x=i/N; y=i%N; // coordonatele casutei 'i' in careul 9*9 -> (x,y)
do {k++;
// daca vp[i][0]=-1 inseamna ca este o valoare impusa/ unica
if (k<=9 && vp[i][0]==-1){// determin solutia unica pentru pozitia 'i'

if(vp[i][k])
{s[x][y]=k; // memorez solutia
q1=1; // solutie corecta (si unica)
if (i<NSQ-1){ // daca careul nu a fost completat in intregime
incearca(i+1, &q1); // trece la casuta urmatoare
if (!q1) // daca sol. e valida se sterge acest numar
{if(vp[i][0]!=-1)// sterg nr. k de pe poz. i
s[x][y]=0;
nr_incercari++; // numara ramurile taiate
}
}
else
// s-a acoperit careul, solutie completa
q1 = 1;// daca s-a acoperit careul se va tipari sol.

}
// se va continua daca nu s-a gasit o solutie (q1=0)
} //si daca mai sunt numere posibile pentru casuta curenta

else if (k<=9 && vp[i][k]){
q1 = 0;
// pozitie ce nu are solutie unica
// initializare indicator 'succes numar'
if (k<=N && valid(i,k))// nr. valid si nu e deja pe lin/col/patrat

{s[x][y] = k; // memorare numar 'k' in casuta (x,y)
if (i < NSQ-1)
{// daca solutia nu e completa se incearca urm poz
incearca (i+1, &q1);
if (!q1) // daca nu este valida se sterge acest nr.
{if(vp[i][0]!=-1) // se sterge doar daca nu e
s[x][y]=0; // val unica pt casuta 'i'
nr_incercari++; // se numara ramurile taiate
}
// (infundate)
}
else
q1 = 1;// daca s-a acoperit careul tipareste
}// se continua daca nu s-a gasit o solutie (q1=0)
}
// si daca mai sunt
} while (!q1 && k<=N); // numere posibile (k<=N) pentru pozitia curenta
*pq = q1; // se transmite reusita sau nereusita plasarii numarului respectiv
}
void main (void) {

int i, j;
init_joc();
for (i=0; i<N; i++) // initializare careul de joc final (solutia)
for(j=0; j<N; j++)
s[i][j]=si[i][j];
printf("Careul initial este urmatorul:\n");
for (i=0; i<N; i++)
{for (j=0; j<N; j++)
if (s[i][j])
printf("%2d", s[i][j]);
else
printf(" ");
printf("\n");
}
incearca(0, &q);// apel pt. i=0, in pozitia (0,0), q-succes joc (solutie)
if (!q)
// acoperire completa careul de joc

printf("Problema nu are solutie !!!\n");
else
{printf("\nSolutia finala este urmatoarea:\n");
for (i=0; i<N; i++)
{for (j=0; j<N; j++)
printf("\n");
}
printf("\nNumarul total de incercari a fost de: %ld\n",nr_incercari);
}
printf("Pentru terminare apasati o tasta!\n");
getch();
}
// sudokuts.cpp - program pentru "acoperirea" unui careu de 81 casute (9*9)

// din care o parte sunt fixate, dupa urmatoarea regula:
// orice linie, coloana sau patrat de 3*3 casute sa contina o singura data
// fiecare cifra cuprinsa intre 1 si 9. Verificarea incrucisata a liniilor
// coloanelor si patratelor mici de 3*3 ofera indicii pentru gasirea solutiei
// se determina si afiseaza toate solutiile gasite, care sunt depuse
// si intr-un fisier al carui nume este: "sudolldd.txt", unde
// ll=luna, dd=data curenta
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <stdlib.h>
#define N 9
#define NSQ N*N
// N - dimensiunea careului de joc; NSQ=N^2;
long int nr_incercari, nr_sol=0;
int si[N][N]={
{2,5,0,0,7,1,0,0,0},
{0,0,3,9,0,0,6,0,0},
{1,0,0,0,0,0,8,0,0},
{0,0,0,0,6,8,2,0,3},
{0,0,0,0,2,3,0,0,0},
{0,0,0,0,0,0,0,4,0},
{0,9,6,0,0,0,0,0,7},
{3,0,0,0,0,0,0,8,5},
{4,0,0,0,0,7,0,0,0}
};
int s[N][N];
int vp[NSQ][N+1];
FILE *ptrf;
struct date d;
void init_joc(){
int i, j, l, c, il, ic, nr1;
clrscr();
printf("\nInitializare careu de joc:\n");
/*for (i=0; i<N; i++){
// initializare careu de joc
printf("Valorile pentru linia %d (separate prin spatii): ", i+1);

for (j=0; j<N; j++)
scanf("%d", &si[i][j]);
}
clrscr(); */
fprintf(ptrf, "Careul initial (%02d.%02d.%d) de completat este urmatorul:\n",
d.da_day, d.da_mon, d.da_year);
for (i=0; i<N; i++)
{for (j=0; j<N; j++){
printf("%2d", si[i][j]);
fprintf(ptrf, "%2d", si[i][j]);
}
printf("\n");
fprintf(ptrf, "\n");
}
for (i=0; i<NSQ; i++)
{vp[i][0]=0; // pozitia curenta (initiala) in cadrul vectorului i
for (j=1; j<=N; j++)
vp[i][j]=1;
l=i/N; c=i%N;
// linia si coloana elementului 'i' din careul 9*9
if (si[l][c]==0)
{
for (il=0; il<N; il++)
if (si[il][c])
vp[i][si[il][c]]=0;
for (ic=0; ic<N; ic++)
if (si[l][ic])
vp[i][si[l][ic]]=0;
l=(i/N/3)*3; c=(i%N/3)*3;// l si c elem 'i' din careul 3*3
for (il=l; il<l+3; il++)
for (ic=c; ic<c+3; ic++)
if (si[il][ic])
vp[i][si[il][ic]]=0;
}
else
{for (ic=1; ic<=N; ic++)
vp[i][ic]=0;
vp[i][0]=-1; // pozitii ce contin valori initiale
vp[i][si[l][c]]=1;
}
nr1=0;// verific daca pentru pozitia i, exista doar 1 nr posibil
for (j=1; j<=N; j++)
if (vp[i][j])
nr1++;
if (nr1==1)
vp[i][0]=-1;
}
for (i=0; i<N; i++)
for (j=0; j<N; j++)
s[i][j]=si[i][j];
/* clrscr();
printf("Matricea numerelor permise pentru fiecare pozitie din careu:\n");
for (i=0; i<NSQ; i++){
if (i%18==0)
{getch();
clrscr();
}
printf("Pozitia [%d,%d] : ", i/N+1, i%N+1);
printf("% d ", vp[i][0]);
for (j=1; j<=N; j++)
if (vp[i][j])
printf("%d ", j);
else
printf("%d ", 0);
printf("\n");
} */
}
int valid(int ip, int k){// fct verifica daca valoarea k poate fi pe poz ip
int l, c, i, j;
l=ip/N; c=ip%N;
// linia si coloana elementului 'ip' din careul 9*9
for (i=0; i<N; i++)

if (k==s[i][c])
return 0;
for (j=0; j<N; j++)
if (k==s[l][j])
return 0;
l=(ip/N/3)*3; c=(ip%N/3)*3;// l si c elem 'ip' din careul 3*3 corespunzat
for (i=l; i<l+3; i++)
for (j=c; j<c+3; j++)
if(k==s[i][j])
return 0;
return 1;
}
void afiseaza_solutie(){
int i, j;
nr_sol++;
printf("\nSolutia %d:\n", nr_sol);
fprintf(ptrf, "\nSolutia %d:\n", nr_sol);
for (i=0; i<N; i++)

{for (j=0; j<N; j++){
fprintf(ptrf, "%2d", s[i][j]);
}
printf("\n");
fprintf(ptrf,"\n");
}
if (nr_sol%2==0){
printf("Pentru a continua apasati o tasta!");
getch();
}
}
void incearca (int i){// determina valoarea urmatoare

int k, x, y;
x=i/N; y=i%N;
for (k=1; k<=N; k++)
if (vp[i][0]==-1){// determin solutia unica pentru pozitia 'i'
if(vp[i][k])
{s[x][y]=k; // memorez solutia
if (i<NSQ-1)
incearca(i+1);
else
afiseaza_solutie();
if(vp[i][0]!=-1) // sterg nr k de pe poz. i
s[x][y]=0;
}
else
nr_incercari++; // numara ramurile taiate
}
else if (vp[i][k])
// pozitie ce nu are solutie unica
if (valid(i,k))// numarul nu e pe lin/col/patrat

{s[x][y] = k; // memorare numar 'i'
if (i < NSQ-1)
incearca (i+1);
else
afiseaza_solutie();
if(vp[i][0]!=-1)
s[x][y]=0;
}
else
nr_incercari++; // se numara ramurile taiate (infundate)
}
void main (void) {

int i, j;
char nume_fis[15]={"sudo____.txt"};
getdate(&d);
nume_fis[4]=d.da_mon/10+'0';
nume_fis[5]=d.da_mon%10+'0';
nume_fis[6]=d.da_day/10+'0';
nume_fis[7]=d.da_day%10+'0';
ptrf=fopen (nume_fis, "w+");
if (!ptrf){printf("Nu se poate crea fisierul cu solutii !!!\n");
exit(1);
}
init_joc();
for (i=0; i<N; i++) // initializare careul de joc final
for(j=0; j<N; j++)
s[i][j]=si[i][j];
printf("Pentru continuare apasati o tasta!\n");
getch();
printf("Careul initial este urmatorul:\n");
for (i=0; i<N; i++)
{for (j=0; j<N; j++)
if (s[i][j])
else
printf(" ");
printf("\n");
}
printf("Pentru continuare apasati o tasta!\n");
getch();
printf("Solutiile sunt urmatoarele:");
incearca(0);// apel pt. i=0, in pozitia (0,0), q-succes nr.
printf("Numar total de solutii: %li\n", nr_sol);
printf("Numarul total de incercari (ramuri arbore incercari): %li\n",
nr_incercari);
fprintf(ptrf, "Numar total de solutii: %li\n", nr_sol);
fprintf(ptrf, "Numarul total de incercari (ramuri arbore incercari): %li\n",
nr_incercari);
fclose(ptrf);
printf("Pentru terminare apasati o tasta!\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
- 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 */
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" );
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. */
#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
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)
{if(i%2)
// pentru valori mai mari ale lui n

// se incrementeaza la cresterea lui
d++; // i spatiul d (din 2 in 2, cu 1)

}
else if((i+1)%2)
d--;
}
// iar pentru partea a doua a
// triunghiului se reduce spatiul

// cu acelasi pas; pentru n>20 trebuie
if ((k+1)%16 == 0){
// modificat 'd' cu un pas mai mare
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();
}
// turcal1s.cpp - program "knight tour": "acoperirea" unei table de sah

// prin mutarile unui cal, astfel incat fiecare casuta a tablei sa fie
// parcursa (atinsa) o singura data; se afiseaza prima solutie gasita
#include <stdio.h>
#include <conio.h>
#define N 5
#define NSQ N*N
#define NrMaxMutCal 8
// N - dimensiunea tablei de sah; NSQ=N^2;
// NrMaxMutCal=8, nr. maxim mutari posibile ale calului, pt. o pozitie data
int i, j, q;
long int nr_incercari;
int h[N+1][N+1];
int a[NrMaxMutCal+1]={0, 1, 1, 2, 2, -1, -1, -2, -2};// poz. relative pe cele doua
int b[NrMaxMutCal+1]={0, 2, -2, 1, -1, 2, -2, 1, -1};// doua coordonate,
// ale celor 8 mutari posibile

void muta (int i, int x, int y, int *pq){// determina mutarea urmatoare
int k, u, v, l, c, q1;
k = 0;
do {
k = k + 1;
// selectie urmatoarea mutare
u = x + a[k];// noile coordonate

v = y + b[k];
q1 = 0;
// initializare indicator 'succes mutare'
if ((u >= 1 && u <= N) && (v >= 1 && v <= N) && (h[u][v] == 0))
// daca mutarea este valida si casuta nu a fost vizitata
{h[u][v] = i; // memorare mutare 'i'
if (i < NSQ)
{// daca sol. nu e completa se incearca mutarea urm.
muta (i+1, u, v, &q1);
if (!q1) // daca nu este valida se sterge mutarea
{h[u][v] = 0;
nr_incercari++; // se numara ramurile taiate
}
// (infundate)
}
else
q1 = 1;// daca s-a acoperit tabla->tipareste solutia
} // se continua daca nu s-a gasit o solutie (q1=0) si daca
} while (!q1 && k < NrMaxMutCal); // mai sunt mutari posibile (k<8)
// din pozitia curenta
*pq = q1;
// se transmite reusita sau nereusita mutarii respective
void main (void) {

int i, j, q;
clrscr();
for (i=1; i<=N; i++)
// initializare tabla de sah,
for (j=1; j<=N; j++) // pentru a memora mutarile urmatoare

h[i][j] = 0;
h[1][1] = 1;
// pozitia de start de pe tabla de sah
muta( 2, 1, 1, &q); // apel mutare 2, din pozitia (1,1),

if (!q)
// q-indicator de succes mutare, acoperire tabla de sah

printf("Problema nu are solutie !!!\n");
else
{for (i=1; i<=N; i++)
{for (j=1; j<=N; j++)
printf("%4d", h[i][j]);
printf("\n");
}
printf("\nNumarul total de incercari a fost de: %ld\n\n",
nr_incercari);
}
}
// turcalts.cpp - program "knight tour" : "acoperirea" unei table de sah

// prin mutarile unui cal, astfel incat fiecare casuta a tablei sa fie
// parcursa (atinsa) o singura data, programul furmizeaza toate solutiile
// posibile, pornind din coltul din stanga sus, pozitia de coordonate (1,1)
#include <stdio.h>
#include <conio.h>
#define N 5
#define NSQ N*N
#define NrMaxMutCal 8
// N - dimensiunea tablei de sah; NSQ=N^2;
// NrMaxMutCal = 8, numarul maxim de mutari posibile ale calului,
// dintr-o pozitie data
int nsl, nsv, nse; // numar de solutii pe linie/ pe veritcala/ si pe ecran

int h[N+1][N+1];
int a[NrMaxMutCal+1] = {0, 1, 1, 2, 2, -1, -1, -2, -2};
// pozitiile relative pe cele doua
int b[NrMaxMutCal+1] = {0, 2, -2, 1, -1, 2, -2, 1, -1};
// coordonate, ale celor 8 mutari posibile
long int nr_sol=0, nr_ramuri=0;
// numar total de solutii, numar de ramuri parcurse pt. a gasi solutiile
void afiseaza_solutie (void) {
int xe, ye, l, c;
xe = nr_sol % nsl; // pozitia pe axa x (orizontala) a solutiei de afisat
ye = (nr_sol / nsl) % nsv; // pozitia pe verticala (y) a solutiei de afisat
for (l=1; l<=N; l++)
for (c=1; c<=N; c++)
{gotoxy(xe*(3*N+2)+c*3, ye*(N+1) + l);
// coordonatele de
printf("%2d", h[l][c]);
// afisare a solutiei
}
nr_sol++;
// contorizare numar de solutii
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 muta ( int m, int x, int y){// determina mutarea urmatoare

int k, u, v;
for (k=1; k<=NrMaxMutCal; k++)
{u = x + a[k];
// noile coordonate ale urmatoarei mutari (u,v)
v = y + b[k];// pornind din pozitia (x,y)

if ((u >= 1 && u <= N) && (v >= 1 && v <= N))
// mutare valida ?
if (h[u][v] == 0) // si care nu a fost acoperita anterior

// daca mutarea este valida si casuta nu a fost vizitata
{h[u][v] = m;
// se memoreaza mutarea
if (m < NSQ) // daca solutia nu este completa incearca

muta (m+1, u, v); // mutarea urmatoare, din poz (u,v)
else
// daca este completa se afiseaza

afiseaza_solutie();
h[u][v] = 0; // dupa afisarea mutarii se sterge mutarea,

}
// pentru a continua cu alta varianta posibila
else
nr_ramuri++;// se numara ramurile taiate (fundaturi)
}
// adica cele parcurse anterior
};
void main (void) {

int il, ic;
clrscr();
nsv = 2;
// initializare pentru N=8
nsl = 2;
// dupa care vor fi actualizate pentru N-ul curent
if (N<6)
{nsl = 4;
// nsl = numar de solutii afisate pe linie
nsv = 4;
// nsv = numar de solutii afisate pe verticala
}
else if (N<8)
{nsl = 3;
if (N == 6)
nsv = 3;
}
nse = nsl*nsv;
// numarul de solutii afisate pe ecran
for (il=1; il<=N; il++) // initializare tabla sah, care va memora mutarile
for (ic=1; ic<=N; ic++)
h[il][ic] = 0;
h[1][1] = 1;
muta( 2, 1, 1);
printf("\nNumar total de solutii: %li\n", nr_sol);
printf("\nNumarul total de incercari (ramuri arbore incercari): %li\n",

nr_ramuri);
}
/* 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
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();
}
/* ciclugrf.c - programul determina toate ciclurile elementare dintr-un

graf cu n noduri si m muchii,
*/
#include <stdio.h>
#include <conio.h>
#define DIMN 10
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++)
a[i][j]=0; // initializare matrice drumuri (costuri) pt. graf
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'
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);
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>
#define DIMN 6
#define DIMM 10
// numar maxim muchii
typedef struct{
int v1, v2;
} 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++)
a[i][j]=0;

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
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);
incerc_culoare(vm, culoare, c, nm, 1);
if(nr_sol)
else
printf("\n");
}
/* drumhip.cpp - programul determina drumul unui concurent pt. un concurs:

concurentul poate incepe concursul din orice punct, dar nu poate
parcurge traseul decat intr-o anumita directie si trecand
cate o singura data prin fiecare punct (matricea grafului va
contine doar cate un 1 pe fiecare linie si pe fiecare coloana):
vom memora intr-un vector dr drumul curent, pornind dintr-un punct
de 'start', si vom determina urmatorul punct din graf, pe care-l
introducem in vector, pana parcurgem toate nodurile grafului.
*/
#include <stdio.h>
#include <conio.h>
#define MAX 20
void cit_graf_orientat (int grf[][MAX], int &n){

int i, j;
int v[][MAX]={
{0, 0, 1, 0, 0, 0, 0, 0},
{0, 0, 0, 1, 0, 0, 0, 0},
{0, 1, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 1, 0, 0},
{0, 0, 0, 0, 0, 0, 1, 0},
{0, 0, 0, 0, 1, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0}};
printf("\nNumarul de noduri (puncte) in graf, n= ");
scanf("%d", &n);
for (i=0; i<n; i++)
{
grf[i][i]=0;
for (j=0; j<n; j++)
if (i!=j)
{grf[i][j]=v[i][j];
/*printf("muchie[%d, %d]= ", i+1, j+1);
scanf("%d", &grf[i][j]); */
}
}
}
void scrie_graf_o (int grf[][MAX], int n){

int i, j;
printf("\nMatricea grafului este urmatoarea:\n");
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
printf("%3d ", grf[i][j]);
printf("\n");
}
printf("\n");
}
void generare_drum(int gf[][MAX], int n, int start, int dr[MAX]){

int k, i, j, p, m, gasit;
// se introduc in vectorul dr[] primele doua noduri in ordinea din graf
i=0;
while (!gf[start][i])
i++;
if (gf[start][i]==1)
{dr[0]=start; dr[1]=i;}
else
{dr[0]=i; dr[1]=start;}
m=2; // numarul de noduri din vectorul dr[]
do
{p=0;
while (!gf[dr[m-1]][p])
p++;
dr[m]=p;
m++;
} while (m<n);
void scrie_drum (int drum[], int n){

int i;
printf("\nDrumul grafului este urmatorul:\n");

for (i=0; i<n; i++)
printf("%3d ", drum[i]);
printf("\n");
}
void main (void) {

int n, g[MAX][MAX], d[MAX], start;
clrscr();
cit_graf_orientat(g, n);
scrie_graf_o(g, n);
printf("\nPunctul de pornire (start) ales din graf: ");
scanf("%d", &start);
generare_drum(g, n, start, d);
scrie_drum(d, n);
getch();
}
/* 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>
#define DIMN 10
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++)

{
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();
}
}
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");
}
/* Floyd.c - programul determina cele mai scurte drumuri dintr-un graf,

utilizand algoritmul Floyd (sau Djikstra modificat),
care poate fi aplicat atat pentru grafuri orientate cat si pentru
cele neorientate (se elimina linia care face simetrica matricea
drumurilor, din functia de citire graf).
*/
#include <stdio.h>
#include <conio.h>
#include <values.h>
#define DIM 6
int D[DIM+1][DIM+1], P[DIM+1][DIM+1], t[DIM+1];

int i, j, k, n, nm, sursa, dest;
char rasp[10];
void main()
{
clrscr();
printf("\nDati numar noduri graf, n: ");
scanf("%d", &n);
scanf("%d", &nm);
for (i=1; i<=n; i++)
for (j=1; j<=n; j++)
{D[i][j]=0;
P[i][j]=0;
// initializare predecesori
}
printf("Se citeste graful prin muchii, nod sursa, dest, si costul asociat.\n");
for (k=1; k<=nm; k++)
{
printf("Muchiile sursa, dest: ");
scanf ("%d%d", &i, &j);
printf("Cost(%d,%d): ", i, j);
scanf("%d", &D[i][j]);
D[j][i]=D[i][j];
// daca graful e orientat se elimina linia urmatoare
// pt. graf neorientat costul (i,j)=cost(j,i)
}
for (i=1; i<=n; i++)
for (j=1; j<=n; j++)
if (D[i][j]==0)
// initializare costuri pentru noduri fara
D[i][j]=1000;
// legaturi (o valoare foarte mare)
else
// initializare predecesor nod 'j'

P[i][j]=i;
for (k=1; k<=n; k++)
// cu nodul liniei (precedent) 'i'
// algoritmul Floyd de determinare a drumului minim
for (i=1; i<=n; i++)
// intre doua noduri 'i' si 'j'
for (j=1; j<=n; j++)
// se verifica toate cazurile i->k->j
if (i != j && D[i][j] > D[i][k]+D[k][j])

{ // daca se determina un k pt. care distanta
D[i][j]=D[i][k]+D[k][j];// este minima
P[i][j]=P[k][j]; // se actualizeaza distanta
} // si se retine nodul precedent lui j
for (i=1; i<=n; i++){
// afisare matrice distante (costuri)
for (j=1; j<=n; j++)

printf("%5d", D[i][j]);
printf("\n");
}
do
{
printf("\nDoriti distanta (costul) intre doua noduri (da/nu)? ");
fflush(stdin); // golire buffer tastatura
gets(rasp);
if (rasp[0]!='d' && rasp[0]!='D')
{fflush(stdin);
printf("\nApasati o tasta pentru a termina programul !\n");
getch();
exit(1);
}
printf("Drumul (costul) intre nodurile sursa, destinatie: ");

scanf("%d%d", &sursa, &dest);
k=dest;
i=0;
while (P[sursa][k] && P[sursa][k] != sursa)
{ // se determina lantul de invers succesori, de la dest
t[++i]=k;
// la sursa, cu cond. sa existe conexiunea
k=P[sursa][k]; // sursa-k, si continua pana ajunge k la sursa

}
t[++i]=k;
t[++i]=sursa;
printf("Drumul (%d->%d): ", sursa, dest);
for (j=i; j>0; j--)
{
if (j!=1)
printf("%2d -> ", t[j]);
else
printf("%2d.", t[j]);
}
printf("\tcost: %d\n", D[sursa][dest]);
} while (rasp[0]=='d' || rasp[0]=='D');
}
/* grafeulr.cpp - programul determina daca un graf este eulerian:

este un graf conex (parcurg in latime, BF, si daca nu exista
varfuri nevizitate este conex) si gradele tuturor varfurilor
sunt pare (grad varf = numar de muchii ce contin varful)

*/
#include <stdio.h>
#include <conio.h>
#define MAX 20
void cit_graf_no (int grf[][MAX], int &n, int grad[]){

int i, j;
int v[][MAX]={
{0, 1, 0, 0, 1, 0, 0, 0},
{1, 0, 1, 0, 0, 0, 0, 0},
{0, 1, 0, 1, 0, 1, 0, 1},
{0, 0, 1, 0, 1, 0, 0, 0},
{1, 0, 0, 1, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0, 1, 0},
{0, 0, 0, 0, 0, 1, 0, 1},
{0, 0, 1, 0, 0, 0, 1, 0}};
printf("\nNumarul de varfuri in graf, n= ");
scanf("%d", &n);
for (i=0; i<n; i++)
grad[i]=0;
for (i=0; i<n; i++)
{
grf[i][i]=0;
for (j=i+1; j<n; j++)
{grf[i][j]=v[i][j];
/*printf("muchie[%d, %d]= ", i+1, j+1);
scanf("%d", &grf[i][j]); */
grf[j][i]=grf[i][j];
if (grf[i][j])
{grad[i]++; grad[j]++;}
}
}
}
void scrie_graf_no (int grf[][MAX], int n, int gd[]){

int i, j;
printf("\nMatricea grafului este urmatoarea:\n");
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
printf("%3d ", grf[i][j]);
printf("\n");
}
printf("Gradele varfurilor grafului sunt:\n");
for (i=0; i<n; i++)
printf("%3d ", gd[i]);
printf("\n");
}
void parcurg_latime (int grf[][MAX], int n, int start, int viz[]){

int i, pi, ps, x, c[MAX];
for (i=0; i<n; i++)
c[i]=0;
// initializare vector varfuri parcurse in latime
for (i=0; i<n; i++)

viz[i]=0;
// initializare vector varfuri vizitate
pi=0;
// indice varf initial (index numar varfuri) in vector
ps=0;
// indice varf de sfarsit in vector
c[pi]=start; // indice varf de start pentru parcurgere in latime

viz[start]=1; // a fost vizitat primul nod (cel de start)
while (ps<=pi)
{x=c[ps];
for (i=0; i<n; i++)
if(grf[x][i]==1 && !viz[i])
{pi++; c[pi]=i;
viz[i]=1;
}
ps++;
}
}
int nevizitat (int viz[], int n){

int prim_nev=-1, j=1;
while (j<=n && prim_nev==-1)
{if (viz[j]==0)
prim_nev=j;
j++;
}
return prim_nev;
int conex (int grf[][MAX], int n, int start, int viz[]){

parcurg_latime (grf, n, start, viz);
if (nevizitat(viz,n)==-1)
return 1;
else
return 0;
}
int grade_pare (int grd[], int n){

int i, ok=1;
for (i=0; i<n && ok; i++)
if (grd[i] %2)
ok=0;
return ok;
}
void main (void) {

int n, g[MAX][MAX], grad[MAX], vizitat[MAX], start;
clrscr();
cit_graf_no(g, n, grad);
scrie_graf_no(g, n, grad);
printf("\n Specificati varful de plecare: ");
scanf("%d", &start);
if (conex(g, n, start, vizitat))
if (grade_pare(grad, n))
printf("\nGraful este conex si eulerian\n");
else
printf("\nGraful este conex dar nu este eulerian\n");
else
printf("\nGraful nu este eulerian\n");
getch();
}
/* graflant.c - programul determina daca exista un lant dat intr-un graf */

#include <stdio.h>
#include <conio.h>
#define DIMN 6
#define DIMM 10

int i, j, k;
clrscr();
scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
a[i][j]=0;
printf("\nCitire graf prin muchiile sursa.\n");
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]])
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_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");
}
/* LantGraf.c - programul determina daca exista un lant dat intr-un graf */

#include <stdio.h>
#include <conio.h>
#define DIMN 6
#define DIMM 10

int i, j, k;
clrscr();
scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
a[i][j]=0;

for (k=1; k<= *pm; k++)
{
printf("Muchie sursa, dest: ");
scanf ("%d%d", &i, &j);
}
}
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]])
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;
return 1;
}
// este ne-elementar
void main()
{
int a[DIMN+1][DIMN+1], l[DIMM+1]; // matricea de adiacenta si lantul cautat
int n, nm, dl, elementar;
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");
}
/* LatBFgrf.c - algoritmul de parcurgere in latime BF a unui graf */

#include <stdio.h>
#include <conio.h>
#define DIMN 10

int i, j, k;
clrscr();

scanf("%d", pn);
scanf("%d", pm);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
a[i][j]=0;

for (k=1; k<= *pm; k++)
{
printf("Muchie, varfuri sursa, dest: ");
scanf ("%d%d", &i, &j);
}
}
void parcurg_lat_BF (int a[DIMN+1][DIMN+1], int C[DIMM+1], int V[DIMM+1],

int n, int prim, int *pdimV){
int k, pi=1, pe=1, v;
// init. pozitie intrare/ 'extragere' C(oada)
for (k=1; k<=n; k++)

C[k]=V[k]=0;
C[1]=prim; // primul varf vizitat
V[prim]=1; // varful 'prim' a fost vizitat
while (pe<=pi){
v=C[pe];
// varful 'extras', v, din coada, C
for (k=1; k<=n; k++)
if (a[v][k] && !V[k]){
// nod vecin ?, nevizitat ?
pi++; // se introduce in coada

C[pi]=k;
// varful k
V[k]=1;
// memorez ca a fost vizitat
}
pe++;// 'extrag' urmatorul varf din coada
}
*pdimV=pi;
}
void main()
{
int a[DIMN+1][DIMN+1]; // matricea de adiacenta
int C[DIMN+1], V[DIMN+1];
// coada varfurilor parcurse, vizitate
int n, nm, primul, dimV, k;

printf("\nProgramul parcurge in latime graful.\n");
printf("\nSpecificati varful de start pentru parcurgere: ");
scanf("%d", &primul);
parcurg_lat_BF(a, C, V, n, primul, &dimV);
printf("\nParcurgerea in latime este urmatoarea:\n");
for (k=1; k<dimV; k++)
printf("%4d - ", C[k]);
printf("%4d\n", C[k]);
printf("Apasati o tasta pentru a termina programul\n");
getch();
}
/* nodizgrf.c - programul determina toate nodurile izolate dintr-un

graf orientat cu n noduri si m muchii,
*/
#include <stdio.h>
#include <conio.h>
#define DIMN 10
typedef struct{
int vi, vf;
} VECT_MUCHII;
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++)
a[i][j]=0; // initializare matrice drumuri (costuri) pt. graf

for (k=1; k<= *pm; k++)
{
printf("Muchia %d, varf initial -> final: ", k);
scanf ("%d%d", &vm[k].vi, &vm[k].vf);
a[vm[k].vi][vm[k].vf]=1; // cost muchie vi-> vf
}
}
void init_nod_iz (int nod_iz[DIMM+1], int nn){

int i;
for (i=1; i<=nn; i++)
nod_iz[i]=0;
}
void determin_nod_iz (int a[DIMN+1][DIMN+1], int nod_iz[DIMN+1], int nn){

int i, j;
for (j=1; j<=nn; j++)
for (i=1; i<=nn; i++)
if (a[i][j])
nod_iz[j]++;
}
void tipar_nod_iz(int nod_iz[DIMM+1], int nn){

int i, ni=0;
printf("\nNoduri izolate:\n");
for (i=1; i<=nn; i++)
// tipareste 'noduri izolate'
if (!nod_iz[i]){
printf("%5d", i);
ni++;
}
printf("\n");
if (ni)
printf("Numar de noduri izolate: %d.\n", ni);
else
printf("\tNu sunt noduri izolate.\n");
}
void main()
{
int nod_iz[DIMM+1], a[DIMN+1][DIMN+1]; // noduri izolate, matr. de adiacenta

int n, nm;
init_nod_iz (nod_iz, n);
determin_nod_iz (a, nod_iz, n);
tipar_nod_iz (nod_iz, n);
printf("\n");
}
/* optigraf.c - programul parcurge optim nodurile dintr-un graf,
plecand dintr-un anumit nod, cu un cost (drum) optim.

Avem grup de n persoane, in care nu toate se cunosc intre ele
(fiecare cunoaste o parte dintre ele); o persoana poseda o carte
pe care doreste sa o transmita grupului, pentru a fi citita de toti
membrii grupului. Fiecare persoana poate transmite cartea doar acelor
persoane pe care le cunoaste. Fiecare persoana citeste si da cartea
intr-un anumit interval de timp (zile), ce depinde de persoana
careia urmeaza sa-i dea cartea, si care va fi specificat pentru
fiecare succesor.
Sa se determine o solutie optima, daca exista, astfel incat cartea sa
treca pe la fiecare persoana din grup, doar o singura data, iar
in final sa ajunga la posesorul cartii, astfel incat timpul dupa
care cartea revine la proprietar sa fie minim (optim).
Programul afiseaza toate solutiile, dar o retine pe cea optima.
*/
#include <stdio.h>
#include <conio.h>
#include <values.h>
#define DIMN 10
typedef struct{
// cele doua varfuri ale unui arc orientat
int vi, vf;
// vi, vf - varfurile initial si final al arcului
int timp;
// timpul necesar pentru a citi cartea
} VECT_MUCHII;
int nr_sol=0, nr_sol_op=0, sol_optima[DIMM+1];
void citire_graf (VECT_MUCHII vm[DIMM+1], int a[DIMN+1][DIMN+1], int *pn){

int i, j, k, durata, pers, np;
clrscr();
scanf("%d", pn);
for (i=1; i<= *pn; i++)
for (j=1; j<=*pn; j++)
a[i][j]=0; // init.(0) matrice drumuri (costuri) pt. graf
printf("\nCitire graf prin varfurile (persoanele) sale.\n");
for (k=1; k<= *pn; k++)
{vm[k].vi=k;
printf("Numarul de persoane cunoscute de persoana (%d): ", k);
scanf("%d", &np);
for (i=1; i<=np; i++){
printf("\tcunostinta(%d): ", i);
scanf("%d", &pers);
vm[k].vf=pers;
printf("\t\ttransferul %d -> %d dureaza (zile): ", k, pers);
scanf("%d", &durata);
a[vm[k].vi][vm[k].vf]=durata;
}
vm[k].timp=durata;
}
printf("\nMatricea costurilor 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 nn){

int i;
// initializeaza solutia cu 0
for (i=1; i<=nn; i++)

solutie[i]=0;
}
int timp_sol(int a[DIMN+1][DIMN+1], int solutie[DIMM+1], int p){

int k, total_timp=0; // timpul total al solutiei determinate
for (k=1; k<p; k++)
total_timp+=a[solutie[k]][solutie[k+1]];
total_timp+=a[solutie[p]][solutie[1]];
return total_timp;
}
void tipar_solutie(int a[DIMN+1][DIMN+1], int solutie[DIMM+1], int p){

int i;
for (i=1; i<=p; i++)
// tipareste solutia 'p'
printf("%d -> ", solutie[i]);

printf("%d\t/timp total=%d/ solutie %d\n\n", solutie[1],
timp_sol(a, solutie, p), nr_sol+1);

if ((nr_sol+1)%10 == 0){ // s-a afisat un ecran, continua ? -> apasa tasta
printf("\nAfisarea continua dupa apasarea unei taste!\n");
getch();
}
}
int validare_solutie (int a[DIMN+1][DIMN+1], int solutie[DIMM+1], int p){

int k;
if ( !a[solutie[p-1]][solutie[p]] ) // nu e legatura -> nu e valida solutia
return 0;
for (k=1; 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;
return 1;
}
void copie_sol_optima(int solutie[DIMM+1], int sol_optima[DIMM+1], int nn){

int i;
for (i=1; i<=nn; i++)
sol_optima[i]=solutie[i];
}
void incerc_solutie(int a[DIMN+1][DIMN+1], int solutie[DIMM+1],

int n, int p, int varf_init, int *poptim){
int i;
for (i=1; i<=n; i++)

{solutie[p]=i;
// initializare varf pe pozitia 'p'
if (validare_solutie(a, solutie, p))

if (p==n && a[solutie[p]][solutie[1]] && // sol completa ?
varf_init==solutie[1])
{tipar_solutie(a, solutie, p);
if (timp_sol(a, solutie, p) < *poptim){
copie_sol_optima(solutie, sol_optima, n);
*poptim=timp_sol(a, solutie, p);
nr_sol_op=nr_sol+1; // numarul sol optime
}
nr_sol++; // contor numar solutii
}
else
incerc_solutie(a, solutie, n, p+1, varf_init, poptim);
solutie[p]=0;
// sterge varful incercat
}
}
void main()
{
int sol[DIMM+1], a[DIMN+1][DIMN+1]; // vect solutie si matricea de adiacenta

int i, n, varf_ini, optim=MAXINT;
citire_graf (vm, a, &n);
printf("Varful initial (persoana de pornire): ");
scanf("%d", &varf_ini);
init_solutie(sol, n);
printf("\nSolutiile din graf sunt urmatoarele:\n");
incerc_solutie(a, sol, n, 1, varf_ini, &optim);
if(nr_sol)
{printf("\nNumarul total de solutii este: %d\n", nr_sol);
printf("\nSolutia optima este:\n");
for (i=1; i<=n; i++)
// tipareste solutia optima
printf("%d -> ", sol_optima[i]);

printf("%d\t/timp total=%d/ solutie %d\n\n", sol_optima[1],
timp_sol(a, sol_optima, n), nr_sol_op);
}
else
printf("\n");
}

Dosar Probleme Fara Comentarii

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Dosar Probleme Fara Comentarii

Încărcat de

Drepturi de autor:

Formate disponibile

#include <stdio.

struct tnod *pstg;

void inserare (ARB * &v, int val){

void inlocuire_nod(ARB * &n){ // n - nodul de eliminat

// e - nodul care se elimina (continutul sau)

// se actualizeaza valorile lui 'e' cu maximul din

// arborele nodului 'n' , ramura dreapta

n=n->pstg; // pastrez legatura la ramura stanga a nodului

// pentru care elimin ramura dreapta, a carei

// valori s-au mutat in nodul 'eliminat' (inlocuit)

void elimina_nod (ARB * &a, int x){// a-arbore, x-valoarea de eliminat

elimina_nod (a->pstg, x);

else if (x > a->nr)

// s-a gasit pozitia lui 'x'

void listare_SRD (ARB *v){

printf("\nListare arbore SRD, dupa eliminarea valorii %d:\n", valoare);

struct tnod *pstg;

void inserare (ARB * &v, int val){

void listare_SRD (ARB *v){

int maxim (int a, int b){

int inaltime (ARB *v){

while ( scanf ("%d", &valoare) != EOF) {

struct tnod *pstg;

void inserare (ARB * &v, int val){

void listare_RSD (ARB *v){

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

if (strcmp(cuv, arb->cuvant) < 0)

else if (strcmp(cuv, arb->cuvant) >0 )

void tiparire_arbore (struct st_arbore *arbo)

struct st_cuvant *urmator;

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

void extragere ( struct st_cuvant * primu)

while (strcmp(cuv, SIR_VID))

typedef int ElTip;

void eroare (char *meserr){

int IncIndexC (int i){

void InitCoada (ACoada pc){

int CoadaGoala (ACoada pc){

return (IncIndexC (pc->ultim) == pc->prim);

int CoadaPlina (ACoada pc){

return (IncIndexC (IncIndexC(pc->ultim)) == pc->prim);

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){

printf("Afisare element din capul cozii: %d\n",

struct st_cuvant *urmator;

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

void extragere ( struct st_cuvant * primu)

printf (" %s -> ", primu->cuvant);

struct s_stiva *adauga_stiva (struct s_stiva *ultimul, int val)

void afisare_stiva(struct s_stiva *ultim)

void eliberare_spatiu (struct s_stiva *ptrs){

printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");

struct s_coada *urmator;

void adaug_coada (struct s_coada *primul, int val)

void afisez_coada(struct s_coada *primul)

void eliberare_spatiu (struct s_coada *ptrs){

struct s_arbore *constr_arbore (void)

if (wherey() > maxy)

struct s_arbore *caut_val (struct s_arbore *p_arb, int numar_cautat,

int maxim (int a, int b) {

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

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

struct s_stiva adauga_stiva (struct s_stiva ultimul, int val)

struct s_arbore caut_val (struct s_arbore p_arb, int numar_cautat,

int numar_aparitii_car (struct st_litera start, char pcar)

struct st_numar inserare (struct st_numar primul, int n){