Probleme Atp

//ARANJAMENTE
#include<stdio.h>
#include<math.h>
#pragma warning (disable:4996)
void init(int n, int st[])
{
int i;
for (i = 0; i < n; i++)
st[i] = 0;
}
void afisare(int n, int st[])

{
int i;
for (i = 0; i < n; i++)
printf("st[%d]=%d ", i, st[i]);
}
int valid(int k, int st[])

{
int ok = 1, i;
for (i = 0; i < k; i++)
if (st[i] == st[k])ok = 0;
return ok;
}
void back(int n, int m, int st[], int* nrsol)

{
int k;
init(n, st);
k = 0;
while (k >= 0)
if (k == m)
{
(*nrsol)++;
printf("Solutia cu nr: %d \n", *nrsol);
afisare(m, st);
printf("\n");
k--;
}
else
if (st[k] < n)
{
st[k] = st[k] + 1;
if (valid(k, st)) k++;
}
else
{
st[k] = 0;
k--;
}
}
void main()
{
int st[10], nrsol = 0;
int n, m;
printf("n=");
scanf("%d", &n);
printf("m=");
scanf("%d", &m);
back(n, m, st, &nrsol);
printf("\n");
printf("nrsol=%d", nrsol);
}
//COMBINARI
#include<stdio.h>
#include<math.h>
{
int i;
for (i = 0; i < n; i++)
st[i] = 0;
}

{
int i;
for (i = 0; i < n; i++)
}

{
int ok = 1, i;
if (k>=1 && st[k-1] > st[k]) ok = 0;
for (i = 0; i < k; i++)
if (st[i] == st[k])ok = 0;
return ok;
}

{
int k;
init(n, st);
k = 0;
while (k >= 0)
if (k == m)
{
(*nrsol)++;
afisare(m, st);
printf("\n");
k--;
}
else
if (st[k] < n)
{
st[k] = st[k] + 1;
}
else
{
st[k] = 0;
k--;
}
}
void main()
{
int n, m;
printf("n=");
scanf("%d", &n);
printf("m=");
scanf("%d", &m);
back(n, m, st, &nrsol);
printf("\n");
}
//GREEDY (iterativ) – solutia optima

#include<stdio.h>
#pragma warning(disable:4996)
void citire(float v[][2], int* n) {
int i, j, h, m;
printf("n=");
scanf("%d", &*n);
for (i = 0; i < *n; i++)

{
printf("\nspectacolul %d \n ", i + 1);
printf("Ora si minutul de inceput = ");
scanf("%d %d", &h, &m);
v[i][0] = h * 60 + m;
printf("Ora si minutul de sfarsit = ");
scanf("%d %d", &h, &m);
v[i][1] = h * 60 + m;
}
}
void afisare(float v[][2], int n, int b[10]) {

int i, j;
for (i = 0; i < n; i++) {
printf("\nspectacolul %d : ", b[i]);
for (j = 0; j < 2; j++)
printf("%5.2f\t", v[i][j]);
printf("\n");
}
}
void sortare(float v[][2], int n, int b[10]) {
int i, j;
float aux;
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (v[i][1] > v[j][1]) {
aux = v[i][0];
v[i][0] = v[j][0];
v[j][0] = aux;
aux = v[i][1];
v[i][1] = v[j][1];
v[j][1] = aux;
aux = b[i];
b[i] = b[j];
b[j] = aux;
}
}
void greedy(float s[][2], int n, int o[], int* k)
{
int i;
float ora;
ora = s[0][0];
*k = 0;
for (i = 0; i < n; i++)
if (s[i][0] >= ora)
{
o[*k] = i;
(*k)++;
ora = s[i][1];
}
}
void main()
{
float v[10][2];
int n, i, b[10], o[10], k;
citire(v, &n);
for (i = 0; i < n; i++)
b[i] = i + 1;
afisare(v, n, b);
sortare(v, n, b);
afisare(v, n, b);
printf("ordinea spectacolelor este ");
greedy(v, n, o, &k);
for (i = 0; i < k; i++)
printf("%d ", b[o[i]]);
}
//PROBLEMA DAMEI
#include<stdio.h>
#include<math.h>
{
int i;
for (i = 0; i < n; i++)
st[i] = 0;
}

{
int i;
for (i = 0; i < n; i++)
}

{
int ok = 1, i;
for (i = 0; i < k; i++)
if (st[i] == st[k] || abs(i - k) == abs(st[i] - st[k]) )ok = 0;
return ok;
}
void back(int n, int st[], int* nrsol)

{
int k;
init(n, st);
k = 0;
while (k >= 0)
if (k == n)
{
(*nrsol)++;
afisare(n, st);
printf("\n");
k--;
}
else
if (st[k] < n)
{
st[k] = st[k] + 1;
}
else
{
st[k] = 0;
k--;
}
}
void main()
{
int n;
printf("n=");
scanf("%d", &n);
back(n, st, &nrsol);
printf("\n");
}
//ROY WARSHALL (graf conex, componenta conexa, nr
comp conexe)
#include<stdio.h>
#include <malloc.h>
int citire(int a[20][20], int* n)
{
int x, y, m, j;
FILE* f;
int er = 1, i;
char nume[20];
printf("numele fisierului este:");
gets_s(nume);
f = fopen(nume, "r");
if (f != NULL)
{
fscanf(f, "%d", &*n);
fscanf(f, "%d", &m);
for (i = 0; i < *n; i++)
for (j = 0; j < *n; j++)
a[i][j] = 0;
for (i = 0; i < m; i++)
{
fscanf(f, "%d", &x);
fscanf(f, "%d", &y);
a[x - 1][y - 1] = a[y - 1][x - 1] = 1;
}
fclose(f);
}
else er = 0;
return er;
}
void afisare(int a[20][20], int n)
{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%d ", a[i][j]);
printf("\n");
}
}
void Roy_Warshall(int a[20][20], int n, int m[20][20])

{
int i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
m[i][j] = a[i][j];
for (k = 0; k < n; k++)
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (m[i][j] == 0) m[i][j] = m[i][k] * m[k][j];
}
void main()
{
int a[20][20], n, m[20][20], i, j;
citire(a, &n);
afisare(a, n);
Roy_Warshall(a, n, m);
printf("\n");
afisare(m, n);
int ok = 1;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (m[i][j] == 0)
ok = 0;
if (ok == 0)
printf("Graful nu este conex");
else
printf("Graful este conex");
int ncc = 0, martor[100], p, v[100];
for (i = 0; i < n; i++) {
martor[i] = 0; v[i] = 0;
}
i = 0;
ok = 0;
while (ok == 0)
{
int nrz = 0;
for (j = 0; j < n; j++)
{
if (m[i][j] == 1) martor[j] = 1;
else nrz = nrz + 1;
}
if (nrz == n) martor[i] = 1;
printf("\n componenta conexa=%d", ncc + 1);

for (j = i; j < n; j++)
if ((martor[j] == 1) && (v[j] == 0)) {
printf("\n%d ", j + 1); v[j] = 1;
}
ok = 1;
for (int l = 0; l < n; l++)
if (martor[l] == 0)
{
i = l;
l = n;
ok = 0;
}
ncc = ncc + 1;
}
printf("\nnumarul componentelor conexe=%d", ncc);
}
//program pentru sortare prin interschimbare
#include<stdio.h>
#include<malloc.h>
int citire(int** v, int* n)

{
int x;
FILE* f;
int er = 1, i;
char nume[20];
gets_s(nume);
*n = 0;
if (f != NULL)
{
while (fscanf_s(f, "%d", &x) > 0)
{
(*n)++;
}
//alocare memorie pentru vector
*v = (int*)malloc((*n) * sizeof(int));
rewind(f);
//preluare elemente vector
i = 0;
while (!feof(f))
{
(*v)[i] = x;
i++;
}
fclose(f);
}
else er = 0;
return er;
}
void afisare(int v[], int n)

{
int i;
for (i = 0; i < n; i++)
printf("%d ", v[i]);
printf("\n");
}
void interclasare(int v[], int li, int ls, int m)

{
int i = li;
int j = m + 1;
int k = 0, b[100];
while (i <= m && j <= ls)
{
if (v[i] < v[j])
b[k++] = v[i++];
else
b[k++] = v[j++];
}
while (i <= m)
b[k++] = v[i++];
while (j <= ls)
b[k++] = v[j++];
int t = li;
for (i = 0; i < (ls - li) + 1; i++)
v[t++] = b[i];
}
void div_imp(int v[], int p, int u)

{
if (p < u)
{
int m = (p + u) / 2;
div_imp(v, p, m);
div_imp(v, m + 1, u);
interclasare(v, p, u, m);
}
}
void main()
{
int* v, n;
citire(&v, &n);
afisare(v, n);
div_imp(v, 0, n - 1);
afisare(v, n);
}
//TOATE SUBMULTIMILE UNEI MULTIMI

#include<stdio.h>
#include<math.h>
{
int i;
for (i = 0; i < n; i++)
st[i] = 0;
}

{
int i;
for (i = 0; i < n; i++)
}
{
int ok = 1, i;
if (k >= 1 && st[k - 1] > st[k]) ok = 0;
for (i = 0; i < k; i++)
if (st[i] == st[k])ok = 0;
return ok;
}

{
int k;
init(n, st);
k = 0;
while (k >= 0)
if (k == m)
{
(*nrsol)++;
afisare(m, st);
printf("\n");
k--;
}
else
if (st[k] < n)
{
st[k] = st[k] + 1;
}
else
{
st[k] = 0;
k--;
}
}
void main()
{
int st[10], nrsol;
int n, i;
printf("n=");
scanf("%d", &n);
nrsol = 1;
printf("Solutia cu nr: %d este multimea vida\n", nrsol);
for(i=1;i<n;i++)
back(n, i, st, &nrsol);
nrsol = nrsol + 1;
printf("Solutia cu nr: %d \n", nrsol);
for (i = 0; i < n; i++)
printf("st[%d]=%d ", i+1, i+1);
printf("\n");
}
//BF PARINTE, DRUM, VF VIZITATE

#include<stdio.h>
#include <malloc.h>
{
int x, y, m, j;
FILE* f;
int er = 1, i;
char nume[20];
gets_s(nume);
if (f != NULL)
{
for (i = 0; i < *n; i++)
for (j = 0; j < *n; j++)
a[i][j] = 0;
for (i = 0; i < m; i++)
{
a[x - 1][y - 1] = a[y - 1][x - 1] = 1;
}
fclose(f);
}
else er = 0;
return er;
}
{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("\n");
}
}
void BF(int a[20][20], int n, int vo, int parinte[20], int m[20], int
coada[20], int* r)
{
int i, k, p, c[20], u;
c[0] = vo - 1;
parinte[vo - 1] = -1;
p = 0; u = 0; *r = 0;
m[vo - 1] = 1;
while (p <= u)
{
i = c[p];
coada[*r] = i;
(*r)++;
for (k = 0; k < n; k++)
if ((a[i][k] == 1) && (m[k] == 0))
{
u = u + 1;
c[u] = k;
parinte[k] = i;
m[k] = 1;
}
p = p + 1;
}
}
void main()
{
int a[20][20], n, vo, parinte[20], m[20], coada[20], r, i;
citire(a, &n);
afisare(a, n);
printf("vo=");
scanf("%d", &vo);
for (i = 0; i < n; i++)
m[i] = 0;
for (i = 0; i < n; i++)
coada[i] = -1;
BF(a, n, vo, parinte, m, coada, &r);
printf("\nvarfurile vizitate:");
for (i = 0; i < r; i++)
printf("%d ", coada[i] + 1);
for (i = 0; i < n; i++)
printf("%d", coada[i] + 1);
for (i = 0; i < n; i++)
if (i != vo - 1)
printf("\nparintele lui %d este %d", i + 1, parinte[i] + 1);
if (r == n)
{
printf("\ndrumul de la %d la %d\n", vo, n - 1);
printf("%d ", n - 1);
int k = n - 2;
while (k != vo - 1)
{
printf(" %d ", parinte[k] + 1);
k = parinte[k];
}
}
//parcurgere in latime
#include<stdio.h>
#include <malloc.h>
{
int x, y, m, j;
FILE* f;
int er = 1, i;
char nume[20];
gets_s(nume);
if (f != NULL)
{
for (i = 0; i < *n; i++)
for (j = 0; j < *n; j++)
a[i][j] = 0;
for (i = 0; i < m; i++)
{
a[x - 1][y - 1] = a[y - 1][x - 1] = 1;
}
fclose(f);
}
else er = 0;
return er;
}
{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("\n");
}
}
void BF(int a[20][20], int n, int vo, int parinte[20], int m[20], int
coada[20], int* r)
{
int i, k, p, c[20], u;
c[0] = vo - 1;
p = 0; u = 0; *r = 0;
m[vo - 1] = 1;
while (p <= u)
{
i = c[p];
coada[*r] = i;
(*r)++;
for (k = 0; k < n; k++)
if ((a[i][k] == 1) && (m[k] == 0))
{
u = u + 1;
c[u] = k;
parinte[k] = i;
m[k] = 1;
}
p = p + 1;
}
}
void main()
{
int a[20][20], n, vo, parinte[20], m[20], coada[20], r, i;
citire(a, &n);
afisare(a, n);
printf("vo= ");
scanf("%d", &vo);
for (i = 0; i < n; i++) m[i] = 0;
for (i = 0; i < n; i++) coada[i] = -1;
BF(a, n, vo, parinte, m, coada, &r);
if (r == n)
printf("graful este conex");
else
printf("graful nu este conex");
}
//CMMDC
#pragma warning(disable: 4996)
#include <stdio.h>
#include <malloc.h>
#include <conio.h>
void citire(float*** a, int* n) {
int i, j;
printf("Introduceti n = "); scanf("%d", &(*n));
(*a) = (float**)malloc((*n) * sizeof(float*));
for (i = 0; i < *n; i++) {
*((*a) + i) = (float*)malloc((*n) * sizeof(float));
}
for (i = 0; i < *n; i++) {
for (j = 0; j < *n; j++) {
printf("[%d][%d]=", i, j); scanf("%f", &((*a)[i][j]));
}
}
}
void afisare(float** a, int n) {
int i, j;
for (i = 0; i < n; i++) {
printf("\n");
for (j = 0; j < n; j++) {
printf("%5.2f ", *(*(a + i) + j));
}
}
}
unsigned int cmmdc(unsigned int a, unsigned int b)
{
if (a == b) return a;
else
if (a > b) return cmmdc(a - b, b);
else return cmmdc(a, b - a);
}
void main()
{
unsigned int x, y;
printf("Introduceti x: ");
scanf("%u", &x);
printf("Introduceti y: ");
scanf("%u", &y);
if (!x || !y) //daca x=0 sau y=0

printf("cmmdc(%u,%u) = 1\n", x, y);
else
printf("cmmdc(%u,%u) = %u\n", x, y, cmmdc(x, y));
getch();
}
//CAUTA UN ELEMENT DIN VECTOR SI II SPUNE POZITIA

#pragma warning(disable: 4996)
#include <stdio.h>
#include <conio.h>
int v[20];
int n, k, c
;
void citire()
{
int i;
printf("Elementele sirului in ordine crescatoare\n");
printf("v[1]=");
scanf("%d", &v[1]);
for (i = 2; i <= n; i++)
do
{
printf("v[% d]= ", i);
scanf("%d", &v[i]);
} while (v[i] <= v[i - 1]);
}
void afisare()
{
int i;
for (i = 1; i <= n; i++)
printf("v[% d] = % d ", i, v[i]);
printf("\n");
}
int cautare(int k, int inf, int sup)
{
int mij;
if (inf <= sup)
{
mij = (inf + sup) / 2;
if (v[mij] == k) return mij;
else if (v[mij] > k)
cautare(k, inf, mij - 1);
else cautare(k, mij + 1, sup);
}
else return 0;
}
void main(void)
{
do
{
printf("n="); scanf("%d", &n);
} while (n < 1 || n>20);
citire();
printf("Vectorul introdus: \n");
afisare();
printf("Numarul cautat in sir = ");
scanf("%d", &k);
c = cautare(k, 1, n);
if (c == 0) printf("Elementul nu este in sir\n");
else printf("Elementul cautat este pe pozitia %d\n", c);
getch();
}
PROBLEME ATP TOATE (EFECTIV TOATE GASITE PRIN TOATE DRIVE-
URILE AMIN DMN AJUTA)
BACKTRACKING
1. Problema celor n regine/dame

/* Backtracking - problema damelor */
#include <stdio.h>
#include <math.h>
int nr, v[100];
int validare(int k)
{
int i;
for (i = 1; i <= k - 1; i++)
if (v[i] == v[k] || abs(v[k] - v[i]) == (k - i))
return 0;
return 1;
}
int solutie(int k)
{
if (k == nr)
return 1;
return 0;
}
void afisare()
{
int i, j;
for (i = 1; i <= nr; i++) {
for (j = 1; j <= nr; j++)
if (v[i] == j)
printf("D ");
else
printf("- ");
printf("\n");
}
printf("\n --------------------------------------------\n");
}
void Backtracking(int k)
{
int i;
for (i = 1; i <= nr; i++) {
v[k] = i;
if (validare(k) == 1)
if (solutie(k) == 1)
afisare();
else
Backtracking(k + 1);
}
}
void main()
{
printf("Introduceti dimensiunea tablei de sah: ");
scanf_s("%d", &nr);
Backtracking(1);
}
2. Generarea tuturor permutarilor
#include <stdio.h>
int n, v[100];
int valid(int k) //verificăm conditiile de continuare
{
int i;
for (i = 1; i <= k - 1; i++) //comparăm fiecare element din vectorul v cu ultimul
element selectat
if (v[i] == v[k]) //deoarece într-o permutare elementele nu au voie să se
repete,
return 0; //returnăm 0 în cazul în care elementul curent a mai fost
selectat anterior
return 1; //returnăm 1 în cazul în care elementul nu mai apare în vector
}
int solutie(int k) //verificăm dacă am obţinut o soluţie
{
if (k == n) //am obţinut o permutare dacă am reuşit să depunem în vector n
elemente
return 1;
return 0;
}
void afisare(int k) //afisarea conţinutului vectorului v
{
int i;
for (i = 1; i <= k; i++)
printf("\n");
}
void BK(int k)
{
int i; //i-elementul selectat din multimea Sk, trebuie sa fie variabilă locală,
pentru a se memora pe stivă
for (i = 1; i <= n; i++) //parcurgem elementele mulţimii Sk
{
v[k] = i; //selectăm un element din mulţimea Sk
if (valid(k)) //verificăm dacă eelementul ales îndeplineşte condiiile de
continuare
{
if (solutie(k)) //verificăm dacă am obţinut o soluţie
afisare(k); //se afişează soluţia obţinută
else
BK(k + 1); //reapelăm funcţia pentru poziţia k+1 din vectorul
v
}
}
}
void main()
{
printf("Introduceti n: ");
scanf_s("%d", &n);
//apelăm funcţia BK pentru completarea poziţiei 1 in vectorul v
BK(1);
}
3. Generarea tuturor aranjamentelor
#include <stdio.h>
int n, v[100], p;
int valid(int k) //verificăm conditiile de continuare
{
int i;
for (i = 1; i <= k - 1; i++) //comparăm fiecare element din vectorul v cu ultimul
element selectat
if (v[i] == v[k]) //deoarece într-o permutare elementele nu au voie să se
repete,
return 0; //returnăm 0 în cazul în care elementul curent a mai fost
selectat anterior
return 1; //returnăm 1 în cazul în care elementul nu mai apare în vector
}
int solutie(int k) //verificăm dacă am obţinut o soluţie
{
if (k == p) //am obţinut o permutare dacă am reuşit să depunem în vector p
elemente
return 1;
return 0;
}
void afisare(int k) //afisarea conţinutului vectorului v
{
int i;
for (i = 1; i <= k; i++)
printf("\n");
}
void BK(int k)
{
int i; //i-elementul selectat din multimea Sk, trebuie sa fie variabilă locală,
pentru a se memora pe stivă
for (i = 1; i <= n; i++) //parcurgem elementele mulţimii Sk
{
v[k] = i; //selectăm un element din mulţimea Sk
if (valid(k)) //verificăm dacă eelementul ales îndeplineşte condiiile de
continuare
{
if (solutie(k)) //verificăm dacă am obţinut o soluţie
afisare(k); //se afişează soluţia obţinută
else
BK(k + 1); //reapelăm funcţia pentru poziţia k+1 din vectorul
v
}
}
}
void main()
{
scanf_s("%d", &n);
printf("Introduceti p: ");
scanf_s("%d", &p);
BK(1);
}
4. Generarea tuturor combinarilor
#include <stdio.h>
int n, v[100], p;
int solutie(int k)
{
if (k == p) return 1;
return 0;
}
void afisare(int k)
{
int i;
for (i = 1; i <= k; i++)
printf("\n");
}
void BK(int k)
{
int i;
for (i = v[k - 1] + 1; i <= n; i++) //la pasul k selectăm din mulţime un element
mai mare decât elementul
{
v[k] = i; //de pe poziţia k-1
if (solutie(k)) //nu este necesar să verificam condiţiile de continuare,
ele sunt respectate
afisare(k); //datorită modului în care am selectat elementele.
else
BK(k + 1);
}
}
void main()
{
scanf_s("%d", &n);
printf("Introduceti p: ");
scanf_s("%d", &p);
BK(1);
}
5. Problema colorarii hartilor

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>
#include<math.h>
int st[20], n, k, a[20][20];
void init()
{
st[k] = 0;
}
int succesor()
{
if (st[k] < 4)
{
st[k]++;
return 1;
}
else return 0;
}
int valid()
{
for (int i = 1; i < k; i++)
if (st[i] == st[k] && a[i][k] == 1) return 0;
return 1;
}
int sol()
{
return (k == n);
}
void tipar()
{
for (int i = 1; i <= n; i++)
printf("Tara numarul %d ce are culoarea %d\n", i, st[i]);
printf("\n\n");
}
void bkt()
{
int as; k = 1;
init();
while (k > 0)
{
do {} while ((as = succesor()) && !valid());
if (as)
if (sol()) tipar();
else { k++; init(); }
else k--;
}
}
void main()
{
printf("Dati numarul de tari:");
scanf("%d", &n);
printf("Dati matricea:\n");
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
bkt();
_getch();
}
6. Plata unei sume cu/fara bancnota unitara
#include <stdio.h>
#define MAX 20
int n = 0, x, v[MAX], w[MAX], z[MAX], S, Suma, sol;
//v-vectorul soluţie,w-valoarea monedelor,z-nr.maxim de monede de un anumit tip
int valid(int k)
{
int i;
Suma = 0;
for (i = 1; i <= k; i++)
Suma = Suma + v[i] * w[i];
if ((Suma <= S) && (k <= n))
return 1;
return 0;
}
int solutie()
{
if (Suma == S)
return 1;
return 0;
}
void afisare(int k)
{
int i;
sol++;
printf("Solutia : %d \n", sol);
for (i = 1; i <= k; i++)
if (v[i])
printf("%d monede de valoarea %d \n", v[i], w[i]);
printf("\n");
}
void BK(int k)
{
int i;
for (i = 0; i <= z[k]; i++)
{
v[k] = i;
if (valid(k) == 1)
{
if (solutie() == 1)
afisare(k);
else
BK(k + 1);
}
}
}
void citire()
{
int i;
FILE* f;
fopen_s(&f, "monede.txt", "r");
if (f == NULL)
printf("Fisierul nu exista");
else {
//se citesc suma S şi numărul de monede
fscanf_s(f, "%d", &S);
fscanf_s(f, "%d", &n);
//se citesc valorile monedelor
for (i = 1; i <= n; i++)
{
fscanf_s(f, "%d", &w[i]);
//z-memoreză numărul maxim de monede de un anumit tip, penru a plati
suma S
z[i] = S / w[i];
}
}
}
void main()
{
citire();
BK(1);
}
7. Problema misionarilor si a canibalilor

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1000
#define EAST 0
#define WEST 1
#define NR_CANNIBALS 3
#define NR_MISSIONARIES 3
#define BOAT_CAPACITY 2
typedef struct Stare {

int m_left;
int c_left;
int m_right;
int c_right;
int boat_pos;
} State;
int solution(State st) {

if (st.m_left == 0 && st.c_left == 0 && st.m_right == NR_MISSIONARIES &&
st.c_right == NR_CANNIBALS) {
return 1;
}
return 0;
}
int stateExisted(State st, State allStates[MAX], int n) {

int i;
for (i = 0; i < n; i++) {
if (allStates[i].m_left == st.m_left && allStates[i].m_right == st.m_right
&&
allStates[i].c_left == st.c_left && allStates[i].c_right ==
st.c_right &&
allStates[i].boat_pos == st.boat_pos) {
return 1;
}
}
return 0;
}
int failure(State st, State allStates[MAX], int n) {

if (stateExisted(st, allStates, n) || st.m_left < 0 || st.m_right < 0 || st.c_left
< 0 || st.c_right < 0) {
return 1;
}
if ((st.m_left < st.c_left && st.m_left>0) || (st.m_right < st.c_right &&
st.m_right>0)) {
return 1;
}
return 0;
}
State move(State currentState, int to, int nrMissionaries, int nrCannibals) {

State nextState = currentState;
if (to == EAST) {
nextState.m_left -= nrMissionaries; nextState.m_right += nrMissionaries;
nextState.c_left -= nrCannibals; nextState.c_right += nrCannibals;
}
else {
nextState.m_left += nrMissionaries; nextState.m_right -= nrMissionaries;
nextState.c_left += nrCannibals; nextState.c_right -= nrCannibals;
}
nextState.boat_pos = to;
return nextState;
}
void search(char path[MAX], State currentState, int boatSide, State allStates[MAX], int
n) {
if (solution(currentState)) {
printf("SOLUTION: %s\n", path);
return;
}
if (failure(currentState, allStates, n)) {
return;
}
// add state
allStates[n++] = currentState;
int direction = 1 - boatSide;
// generate all possible moves

int i, j, k;
for (i = 1; i <= BOAT_CAPACITY; i++) {
for (j = 0; j <= i; j++) { // missionaries
k = i - j; // cannibals
char cj[20], ck[20];
sprintf(cj, "%d", j);
sprintf(ck, "%d", k);
char newPath[MAX] = "";
if (strcmp(path, "") != 0) {
strcat(newPath, path);
strcat(newPath, "; ");
}
strcat(newPath, cj);
strcat(newPath, "M-");
strcat(newPath, ck);
strcat(newPath, "C");
search(newPath, move(currentState, direction, j, k), direction,
allStates, n);
}
}
}
int main() {
State allStates[MAX];
State init;
init.m_left = 3; init.m_right = 0;
init.c_left = 3; init.c_right = 0;
init.boat_pos = WEST;
char path[MAX] = "";

search(path, init, WEST, allStates, 0);
return 0;
}
8. Problema cavalerilor mesei rotunde

#include<stdio.h>
#include<math.h>
#include<malloc.h>
//verificam daca valoarea lui i e acceptata
int posibil(int *v,int i, int n)

{
int j, r;
r = 1;
j = 0;
while ((j < i) && (v[i] != v[j]))
j++;
if (j < i)
r = 0;
if (i > 0)
r = (r && (abs(v[i] - v[i - 1])==2|| abs(v[i] - v[i - 1])== 3));
if (i == n - 1)
r = (r && (abs(v[n - 1] - v[0])== 2|| abs(v[n - 1] - v[0])== 3));
return r;
}
//afisarea solutiei pe ecran// intra: num-numar solutii,n-dimensiunea, v-solutia
void retine_solutia(int num, int n, int *v)

{
int i; int *y;
y = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; i++)
printf("\nSolutia nr. %d:", num);
for (i = 0; i < n; i++)
printf("Cavalerul %2d se aseaza pe locul %2d \n", v[i], i + 1);
free(y);
}
//n-dimensiunea, i-pas curent, x-sol partiala curenta

//nr-nr crt solutii// iese nr-numar solutii
int cavaleri(int n, int i, int *x, int nr)

{
int j;
if (i == n)
retine_solutia(++nr,n,x);
else
for (j = 1; j <= n; j++)
{
x[i] = j;
if (posibil(x, i, n))
nr = cavaleri(n,i + 1, x, nr);
}
return nr;
}
void main ()
{
int n;
printf("numarul de persoane=");
scanf("%d", &n);
int *x = (int*)malloc(n * sizeof(int));
int nr=cavaleri(n,0,x,0);
if (nr == 0)
printf("nu exista solutii de asezat");
free(x);
}
9) Problema turelor
/* Backtracking - problema turelor */
#include <stdio.h>
int nr, v[100];
int validare(int k) {
int i;
for (i = 1; i <= k - 1; i++)
if (v[i] == v[k])
return 0;
return 1;
}
int solutie(int k) {
if (k == nr)
return 1;
return 0;
}
void afisare() {
int i, j;
for (i = 1; i <= nr; i++) {
for (j = 1; j <= nr; j++)
if (v[i] == j)
printf("T ");
else
printf("- ");
printf("\n");
}
printf("\n --------------------------------------------\n");
}
void Backtracking(int k) {
int i;
for (i = 1; i <= nr; i++) {
v[k] = i;
if (validare(k) == 1)
if (solutie(k) == 1)
afisare();
else
Backtracking(k + 1);
}
}
void main()
{
printf("Introduceti dimensiunea tablei de sah: ");
scanf_s("%d", &nr);
Backtracking(1);
10) Generarea tuturor submultimilor unei multimi

#include <conio.h>
#include<stdio.h>
char sp[] = " ";
int x[20], n, nrsol = 0;
void Afisare()
{
int i;
printf("%c {", sp);
for (i = 1; i <= n; i++)
if (x[i] == 1) printf("%d ", i);
printf(" }\n");//cout<<char(8)<<"}"<<endl;
nrsol++;
//if (nrsol%22==0) _getch();//cin.get();
}
void BackRec(int k)
{
int i;
for (i = 0; i <= 1; i++)
{
x[k] = i;
if (k == n) Afisare();
else BackRec(k + 1);
}
}
int main()
{
printf("\n\nSubmultimile multimii {1,2,3.....,n}\n ");
//cout<<endl<<endl<<sp<<"Submultimile multimii {1,2,3.....,n}"<<endl;
printf(" Dati valoarea unui n:");
scanf("%d", &n); //cout<<endl<<sp<<" Dati valoarea lui n: "; cin>>n;
printf("\n"); //cout<<endl;
BackRec(1);
printf("Nr. solutii: %d\n", nrsol); //cout<<endl<<sp<<"Numar solutii: "<<nrsol;
_getch();
return 0;
}
GRAFURI
1. Parcurgerea in latime-BF
#include <stdio.h>
#include <conio.h>
#include<malloc.h>
int inserare_in_coada(int* coada, int n, int vf)

{
coada[n] = vf;
n++;
return n;
}
int extrage_nod_din_coada(int* coada, int n, int* vf)

{
int i;
*vf = coada[0];
for (i = 0; i < n - 1; i++)
coada[i] = coada[i + 1];
n=n-1;
return n;
}
void parcurgere_in_latime(int v0, int** a, int n)

{
int* coada, * m, i, nr_c, k;
coada = (int*)malloc(n * sizeof(int));
m = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; m[i++] = 0);
nr_c = 0;
nr_c = inserare_in_coada(coada, nr_c, v0);
m[v0] = 1;
while (nr_c)
{
nr_c = extrage_nod_din_coada(coada, nr_c, &i);
printf("\n%i", i + 1);
for (k = 0; k < n; k++)
if ((a[i][k] == 1) && (m[k] == 0))
{
nr_c = inserare_in_coada(coada, nr_c, k);
m[k] = 1;
}
}
free(coada);
free(m);
}
void main()
{
int n, v0, ** a, m, i, j, vf1, vf2;
printf("Introduceti numarul de varfuri:");
scanf("%d", &n);
a = (int**)malloc(n * sizeof(int*));
for (i = 0; i < n; i++)
a[i] = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; i++)
for (j = 0; j <= i; j++)
a[j][i] = a[i][j] = 0;
printf("Introduceti numarul de muchii:");
scanf("%d", &m);
for (i = 0; i < m; i++)
{
printf("Introduceti varf initial pentru muchie:");
scanf("%d", &vf1);
printf("Introduceti varf final pentru muchie:");
scanf("%d", &vf2);
a[vf1 - 1][vf2 - 1] = a[vf2 - 1][vf1 - 1] = 1;
}
printf("\Introduceti varful initial pentru parcurgerea BF ");
scanf("%d", &v0);
printf("\nOrdinea de vizitare a virfurilor grafului este:");
parcurgere_in_latime(v0 - 1, a, n);
//se va elibera zona de memorie alocata pentru matricea a
for (i = 0; i < n; i++)
free(a[i]);
free(a);
}
2. Pracurgerea in adancime a grafurilor DF
#include <stdio.h>
#include <conio.h>
#include<malloc.h>
int inserare_nod_in_stiva(int* stiva, int n, int vf)
{
int i;
for (i = n - 1; i >= 0; i--)
stiva[i + 1] = stiva[i];
stiva[0] = vf;
n++;
return n;
}
int stergere_nod_din_stiva(int* stiva, int n)
{
int i;
for (i = 0; i < n - 1; i++)
stiva[i] = stiva[i + 1];
n--;
return n;
}
int citeste_stiva(int* stiva, int n)
{
return stiva[0];
}
void parcurgere_in_adancime(int v0, int** a, int n)

{
int* stiva, * m, i, nr_c, gasit;
// se aloca memorie pentru stiva si pentru m – n elemente
stiva = (int*)malloc(n * sizeof(int));
m = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; m[i++] = 0);
nr_c = 0;
nr_c = inserare_nod_in_stiva(stiva, nr_c, v0);
m[v0] = 1;
printf("\n%i", v0 + 1);
while (nr_c)
{
i = citeste_stiva(stiva, nr_c);
gasit = 0;
for (int k = 0; (k < n) && !gasit; k++)
if ((a[i][k] == 1) && (m[k] == 0))
{
nr_c = inserare_nod_in_stiva(stiva, nr_c, k);
m[k] = 1;
printf("\n%i", k + 1); gasit = 1;
}
if (!gasit)
nr_c = stergere_nod_din_stiva(stiva, nr_c);
}
//eliberare memorie alocata – pentru stiva si pentru m;
free(stiva); free(m);
}
void main()
{
int n, v0, ** a, m, i, j, vf1, vf2;;
printf("Introduceti numarul de varfuri:");
scanf("%d", &n);
a = (int**)malloc(n * sizeof(int*));
for (i = 0; i < n; i++)
a[i] = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; i++)
for (j = 0; j <= i; j++)
a[j][i] = a[i][j] = 0;
printf("\Introduceti numarul de muchii:");
scanf("%d", &m);
for (i = 0; i < m; i++)
{
printf("Introduceti nod initial pentru muchie");
scanf("%d", &vf1);
printf("Introduceti nod final pentru muchie:");
scanf("%d", &vf2);
a[vf1 - 1][vf2 - 1] = a[vf2 - 1][vf1 - 1] = 1;
}
printf("\nIntroduceti nodul initial pentru parcurgerea DF ");
scanf("%i", &v0);
printf("\nOrdinea de vizitare a varfurilor grafului este:");
parcurgere_in_adancime(v0 - 1, a, n);
for (i = 0; i < n; i++) free(a[i]);
free(a);
}
3. Parcurgeri generalizate DFG & BFG

4. Preluare graf in forma tabelara din fisier text
//graf neponderat
#include<stdio.h>
#include<malloc.h>
int citire_graf(char numefisier[20], int* nr_vrf, int* nr_muchii, int*** g)
{
FILE* f;
int i,er;
fopen_s(&f, numefisier, "r+t");
if (f == NULL)
er = 1;
else
{
er = 0;
fscanf_s(f,"%d %d", nr_vrf, nr_muchii);
*g = (int**)malloc(*nr_muchii* sizeof(int*));
for (i = 0; i < *nr_muchii; i++)
(*g)[i] = (int*)malloc(2 * sizeof(int));
fscanf_s(f,"%d %d", & (*g)[i][0], & (*g)[i][1]);
fclose(f);
}
return er;
}
void main()
{
char numefisier[20];
int n, m, ** tabel, er;
printf("Introduecti fisierul din care cititi graful:");
gets_s(numefisier);
er = citire_graf(numefisier, &n, &m, &tabel);
printf("Numarul de varfuri este:%d", n);
printf("Numarul de muchii este:%d", m);
printf("Muchiile sunt:\n");
int i;
for (i = 0; i < m; i++)
printf("%d %d\n", tabel[i][0], tabel[i][1]);
}
//graf ponderat
#include<stdio.h>
#include<malloc.h>
{
FILE* f;
int i,er;
if (f == NULL)
er = 1;
else
{
er = 0;
fscanf_s(f,"%d %d", nr_vrf, nr_muchii);
*g = (int**)malloc(*nr_muchii* sizeof(int*));
fscanf_s(f,"%d %d %d", & (*g)[i][0], & (*g)[i][1], &(*g)[i][2]);
fclose(f);
}
return er;
}
void main()
{
gets_s(numefisier);
int i;
for (i = 0; i < m; i++)
{
printf("%d %d ", tabel[i][0], tabel[i][1]);
printf("Ponderea muchiei este: %d\n", tabel[i][2]);
}
}
5. Coversie reprezentare tabelara in reprezentare

matriceala
//graf neponderat
#include<stdio.h>
#include<malloc.h>
{
FILE* f;
int i, er;
if (f == NULL)
er = 1;
else
{
er = 0;
fscanf_s(f, "%d %d", nr_vrf, nr_muchii);
*g = (int**)malloc(*nr_muchii * sizeof(int*));
fscanf_s(f, "%d %d", &(*g)[i][0], &(*g)[i][1]);
fclose(f);
}
return er;
}
int** conversie_matrice(int nr_vrf, int nr_muchii, int** tabel, int* dim)
{
int i, j;
int** mat;
*dim = nr_vrf;
mat = (int**)malloc(*dim * sizeof(int*));
for (i = 0; i < *dim; i++)
mat[i] = (int*)malloc(*dim * sizeof(int*));
for (i = 0; i < *dim; i++)
{
for (j = 0; j < *dim; j++)
mat[i][j] = 0;
}
for (i = 0; i < nr_muchii; i++)
{
mat[tabel[i][0] - 1][tabel[i][1] - 1] = 1;
mat[tabel[i][1] - 1][tabel[i][0] - 1] = 1;
}
return mat;
}
void main()
{
gets_s(numefisier);
int i,j;
for (i = 0; i < m; i++)
printf("%d %d\n", tabel[i][0], tabel[i][1]);
int** a, dim;
a = conversie_matrice(n, m, tabel, &dim);
printf("\nMatricea de adiacenta este:\n");
for (i = 0; i < dim; i++)
{
for (j = 0; j < dim; j++)
printf("\n");
}
//graf ponderat
#include<stdio.h>
#include<malloc.h>
#define INF 1000
{
FILE* f;
int i, er;
if (f == NULL)
er = 1;
else
{
er = 0;
fscanf_s(f, "%d %d", nr_vrf, nr_muchii);
*g = (int**)malloc(*nr_muchii * sizeof(int*));
fscanf_s(f, "%d %d %d", &(*g)[i][0], &(*g)[i][1], &(*g)[i][2]);
fclose(f);
}
return er;
}
int** conversie_matrice(int nr_vrf, int nr_muchii, int** tabel, int* dim)

{
int i, j;
int** mat;
*dim = nr_vrf;
mat = (int**)malloc(*dim * sizeof(int*));
for (i = 0; i < *dim; i++)
mat[i] = (int*)malloc(*dim * sizeof(int*));
for (i = 0; i < *dim; i++)
{
for (j = 0; j < *dim; j++)
mat[i][j] = INF;
}
for (i = 0; i < nr_muchii; i++)
{
mat[tabel[i][0] - 1][tabel[i][1] - 1] = tabel[i][2];
mat[tabel[i][1] - 1][tabel[i][0] - 1] = tabel[i][2];
}
return mat;
}
void main()
{
gets_s(numefisier);
int i,j;
for (i = 0; i < m; i++)
{
printf("%d %d ", tabel[i][0], tabel[i][1]);
printf("Ponderea muchiei este: %d\n", tabel[i][2]);
}
int** a, dim;
a = conversie_matrice(n, m, tabel, &dim);
printf("\nMatricea de adiacenta este:\n");
for (i = 0; i < dim; i++)
{
for (j = 0; j < dim; j++)
printf("\n");
}
6. Obtinere lista de adiacente
7. Roy-Warshall pentru matricea existentei

drumurilor
//introducere date de la tastatura

#include<stdio.h>
void Roy_Warshall(int a[10][10], int m[10][10], int n)

{
int i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
m[i][j] = a[i][j];
for (j = 0; j < n; j++)
for (i = 0; i < n; i++)
if (m[i][j] != 0)
for (k = 0; k < n; k++)
if (m[i][k] < m[k][j])
m[i][k] = m[k][j];
}
void main()
{
int a[10][10], n, nm, i, j, u, v, m[10][10];
printf("Introduceti numarul de noduri:");
scanf_s("%d", &n);
scanf_s("%d", &nm);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
a[i][j] = 0;
for (i = 0; i < nm; i++)
{
printf("Introduceti nod initial muchie:");
scanf_s("%d", &u);
printf("Introduceti nod final muchie:");
scanf_s("%d", &v);
a[u - 1][v - 1] = a[v - 1][u - 1] = 1;
}
Roy_Warshall(a, m, n);
printf("Matricea existentei drumurilor este:\n");
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
printf("%d ", m[i][j]);
printf("\n");
}
}
//preluare graf din fisier text

#include <stdio.h>
#include <malloc.h>
//I: matricea de adiacenta, nr. vârfuri

//E: matricea existentei drumurilor, dimensiune
int** Roy_Warshall(int** a, int n)

{
int i, j, k;
int** m;
m = (int**)malloc(n * sizeof(int*));
for (i = 0; i < n; i++)
m[i] = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
m[i][j] = a[i][j];
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
if (m[i][j] == 1)
for (k = 0; k < n; k++)
if (m[i][k] < m[k][j])
m[i][k] = m[k][j];
return m;
}
//preia graful din fisierul text
void preia_graf(char* nume, int*** a, int* n)
{
int i, j, m, u, v;
FILE* f;
fopen_s(&f, nume, "rt");

fscanf(f, "%i", n);
int** mw = (int**)malloc(*n * sizeof(int*));

for (i = 0; i < *n; i++)
mw[i] = (int*)malloc(*n * sizeof(int));
fscanf(f, "%i", &m);

for (i = 0; i < *n; i++)
for (j = 0; j < *n; j++)
mw[i][j] = 0;
for (i = 0; i < m; i++)

{
fscanf(f, "%i", &u);
fscanf(f, "%i", &v);
mw[u - 1][v - 1] = mw[v - 1][u - 1] = 1;
}
fclose(f);
*a = mw;
}
void main()
{
int** a, ** m_dr;
int n, i, j;
char numef[20];
printf("Introduceti numele fisierului care contine graful:");

scanf("%s", numef);
preia_graf(numef, &a, &n);

m_dr = Roy_Warshall(a, n);
for (i = 0; i < n; i++) {

for (j = 0; j < n; j++)
printf("%3i ", m_dr[i][j]);
printf("\n");
}
for (i = 0; i < n; i++) free(a[i]);
free(a);
for (i = 0; i < n; i++) free(m_dr[i]);
free(m_dr);
}
8. Verificare conexitate graf cu Roy-Warshall

//introducere date de la tastatura
#include<stdio.h>
void Roy_Warshall(int a[10][10], int m[10][10], int n)

{
int i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
m[i][j] = a[i][j];
for (j = 0; j < n; j++)
for (i = 0; i < n; i++)
if (m[i][j] != 0)
for (k = 0; k < n; k++)
if (m[i][k] < m[k][j])
m[i][k] = m[k][j];
}
int verificare_conexitate(int m[10][10], int n)

{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (m[i][j] == 0)
return 0;
return 1;
}
void main()
{
int a[10][10], n, nm, i, j, u, v, m[10][10];
printf("Introduceti numarul de noduri:");
scanf_s("%d", &n);
scanf_s("%d", &nm);
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
a[i][j] = 0;
for (i = 0; i < nm; i++)

{
printf("Introduceti nod initial muchie:");
scanf_s("%d", &u);
printf("Introduceti nod final muchie:");
scanf_s("%d", &v);
a[u - 1][v - 1] = a[v - 1][u - 1] = 1;
Roy_Warshall(a, m, n);
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%d ", m[i][j]);
printf("\n");
}
int conex = verificare_conexitate(m, n);

if (conex == 1)
printf("\nGraful este conex");
else
printf("\nGraful nu este conex");
}
//citire graf din fisier text

#include <stdio.h>
#include <malloc.h>
int** Roy_Warshall(int** a, int n)

{
int i, j, k;
int** m;
m = (int**)malloc(n * sizeof(int*));
for (i = 0; i < n; i++)
m[i] = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
m[i][j] = a[i][j];
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
if (m[i][j] == 1)
for (k = 0; k < n; k++)
if (m[i][k] < m[k][j])
m[i][k] = m[k][j];
return m;
}
void preia_graf(char* nume, int*** a, int* n)
{
int i, j, m, u, v;
FILE* f;
fopen_s(&f, nume, "rt");

fscanf(f, "%i", n);
int** mw = (int**)malloc(*n * sizeof(int*));

for (i = 0; i < *n; i++)
mw[i] = (int*)malloc(*n * sizeof(int));
for (i = 0; i < *n; i++)

for (j = 0; j < *n; j++)
mw[i][j] = 0;
for (i = 0; i < m; i++)

{
mw[u - 1][v - 1] = mw[v - 1][u - 1] = 1;
}
fclose(f);
*a = mw;
}
int verificare_conexitate(int **m, int n)

{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (m[i][j] == 0)
return 0;
return 1;
}
void main()
{
int** a, ** m_dr;
int n, i, j;
char numef[20];

scanf("%s", numef);
preia_graf(numef, &a, &n);

m_dr = Roy_Warshall(a, n);
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%3i ", m_dr[i][j]);
printf("\n");
}
int conex = verificare_conexitate(m_dr, n);
if (conex == 1)
printf("\nGraful este conex");
else
printf("\nGraful nu este conex");
for (i = 0; i < n; i++) free(a[i]);
free(a);
for (i = 0; i < n; i++) free(m_dr[i]);
free(m_dr);
}
9. Determinarea numarului de componente conexe ale

unui graf
//cu parcurgere in adancime DF SI PRELUARE GRAF DIN
FISIER TEXT
#include <conio.h>
#include <stdio.h>
int v[15], n;
int a[15][15];
//preluarea grafului din fisier text (numar de noduri + perechile de muchii)

void citire(FILE* f)
{
int i, j;
fopen_s(&f, "graf.txt", "r+");
//citire numar noduri din fisier
fscanf_s(f, "%i", &n);
//citirea perechilor de muchii si initializarea matricei de adiacenta
while (!feof(f))
{
fscanf_s(f, "%i", &i);
fscanf_s(f, "%i", &j);
a[i][j] = a[j][i] = 1;
}
}
//algoritm parcurgere DF
void DF(int x)
{
int i;
v[x]++;
printf("%i ", x);
for (i = 1; i <= n; i++)
{
if (a[x][i] == 1 && v[i] == 0)
DF(i);
}
}
//subprogram pentru determinarea numarului de componente conexe
int conexe()
{
int k = 0, i;
for (i = 1; i <= n; i++)
{
if (v[i] == 0)
{
printf("Componenta conexa %i e formata din nodurile ", k + 1);
k++;
DF(i);
printf("\n");
}
}
return k;
}
void main()
{
int x;
FILE* f = NULL;
citire(f);
printf("Nr de componente conexe este %i .", conexe());
}
//cu parcurgere BF si introducere graf de la

tastatura
//adaugam o variabila care numara cate componente conexe avem; se afla in void
#include<stdio.h>
void adiacenta(int a[20][20], int* n) //pt ca il citesc in subprogram si trebuie sa il

transmit trebuie sa fie dinamic
{
int i, j, m, x, y;
printf("Numarul de noduri:");
scanf("%i", &*n);
printf("Numarul de muchii:");
scanf("%i", &m);
for (i = 0; i < *n; i++)

for (j = 0; j < *n; j++)
a[i][j] = 0;
printf("Introduceti muchiile: \n");

for (i = 0; i < m; i++)
{
printf("v[i]=");
scanf(" %i", &x);
printf("v[f]=");
scanf(" %i", &y);//localizarea nodului a[x][y]
a[x - 1][y - 1] = a[y - 1][x - 1] = 1;

}
}

{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%i", a[i][j]);
printf("\n");
}
}
void BF(int a[20][20], int n, int c[20], int vo, int* u, int parinte[20])
{
int m[20], i, k, p;
//initializez vectorul martor m cu 0 (in m se retine daca varfurile au fost

introduse in coada sau nu; 0=nu, 1=da)
for (i = 0; i < n; i++)
m[i] = 0;
c[0] = vo - 1;
p = 0;
*u = 0;
m[vo - 1] = 1;
while (p <= (*u))

{
i = c[p];
for (k = 0; k < n; k++)
if ((a[i][k] == 1) && (m[k] == 0))
{
(*u) = (*u) + 1;
c[(*u)] = k;
parinte[k] = i;
m[k] = 1;
}
p = p + 1;
}
}
void main()
{
int a[20][20], n, parinte[20], c[20], vo, u, i, nr = 0, k, e;// u imi intoarce din
bf nr nodurilor vizitate, un c= varfurile vizitate, parinte=imi arata cine este este
parintele
adiacenta(a, &n);
afisare(a, n);
for (i = 0; i < n; i++)

c[i] = 0;
for (i = 0; i < n; i++)

parinte[i] = 1000; //dau ca parinte un numar foarte mare
printf("Citeste vo=");
scanf("%d", &vo);
BF(a, n, c, vo, &u, parinte);
nr = nr + 1;
printf("Varfurile vizitate:");
for (i = 0; i <= u; i++)
printf(" %d ", c[i] + 1);
printf("Parinte: ");
for (i = 0; i <= u; i++)
printf("\n parinte[%d]=%d", i + 1, parinte[i] + 1);
//verific daca am componente conexe
for (i = 0; i < n; i++)

if ((c[i] == 0) && (i != vo - 1)) //daca locul sau in coada este tot
neocupat (a fost initializata coada cu 0 si fiecare element si-a ocupat locul in coada),
iar acel varf nu este varful initial de la care am plecat inseamna ca avem componente
conexe
{
nr++;
BF(a, n, c, (i + 1), &u, parinte);
e = i;//
for (k = 0; k <= u; k++)
{
c[e] = c[k];//dau fiecarui nod din graful respectiv indicele
componentei conexe din care face parte
printf("%d", c[k] + 1);
}
e++;
for (k = 0; k <= u; k++)

printf("%d", c[i] + 1);
if (nr == 1)
printf("\ngraf conex");
else
printf("\nNumarul de componente conexe este %d", nr);
10. Dijkstra cu preluare graf din fisier

#include <stdio.h>
#include <malloc.h>
#define INF 1000000
typedef struct {
float l;
int vf;
}eticheta;
//subprogram
//preia datele unui graf in forma tabelara din fisierul nume si obtine
//matricea ponderilor, unde INF este valoarea cu semnificatie de infinit
//ultima linie a fisierului contine virful initial din algoritmul Dijkstra
//subprogram
//functia pentru implementarea algoritmului Dijkstra - returneaza
//vectorul de etichete
//subprogram
//functia principala
void preia_graf(char* nume, float*** w, int* n, int* v0)

{
int i, j, m, u, v; float p;
FILE* f = fopen(nume, "rt");
fscanf(f, "%i", n);
float** mw = (float**)malloc(*n * sizeof(float*));

for (i = 0; i < *n; i++)
mw[i] = (float*)malloc(*n * sizeof(float));
for (i = 0; i < *n; i++)

for (j = 0; j < *n; j++)
mw[i][j] = INF;
for (i = 0; i < m; i++)

{
fscanf(f, "%f", &p);
mw[u - 1][v - 1] = mw[v - 1][u - 1] = p;
}
fscanf(f, "%i", v0);

fclose(f);
*w = mw;
}
eticheta* Dijkstra(float** w, int n, int v0)

{
int i, * prel, nrit, ui, v, vmin;
float lmin;
eticheta* v_et = (eticheta*)malloc(n * sizeof(eticheta));
for (i = 0; i < n; i++)

v_et[i].l = INF;
v_et[v0 - 1].l = 0;
prel = (int*)malloc(n * sizeof(int));

//vector cu proprietatea prel[i]=1 daca pentru virful i+1 a
//fost deja determinat un drum de cost minim
//prel[i]=0 in caz contrar
for (i = 0; i < n; i++)
prel[i] = 0;
prel[v0 - 1] = 1;
ui = v0;
for (nrit = 0; nrit < n - 1; nrit++)
{
lmin = INF;
//sunt recalculate w-distantele de la virfurile v cu prel[v-1]=0 si este
determinat vmin, //urmatorul virf cu proprietatea ca pentru acesta a fost determinat un
drum de cost minim,
// lmin
for (v = 1; v <= n; v++)
{
if ((prel[v - 1] == 0) && (v_et[v - 1].l > v_et[ui - 1].l + w[v -
1][ui - 1]))
{
v_et[v - 1].l = v_et[ui - 1].l + w[v - 1][ui - 1];
v_et[v - 1].vf = ui;
}
if ((prel[v - 1] == 0) && v_et[v - 1].l < lmin)
{
lmin = v_et[v - 1].l; vmin = v;
}
}
ui = vmin; prel[ui - 1] = 1;
}
free(prel); return v_et;
}
void main()
{
float** w;
int n, v0, v, u, i;
char numef[20];
scanf("%s", numef);
preia_graf(numef, &w, &n, &v0);
eticheta* rez = Dijkstra(w, n, v0);
for (v = 1; v <= n; v++)
if (v != v0)
{
printf("Costul unui cel mai ieftin drum de la %i la %i este %8.3f",
v, v0, rez[v - 1].l);
printf("\n Un drum de cost minim: %i ", v);
u = v;
while (rez[u - 1].vf != v0)
{
printf("%i ", rez[u - 1].vf);
u = rez[u - 1].vf;
}
printf("%i \n\n", v0);
}
free(rez);
for (i = 0; i < n; i++) free(w[i]);
free(w);
}
11)Roy-Floyd cu introducere garf de la tastatura
#include<stdio.h>
#define INF 100
void Roy_Floyd(int w[10][10], int n, int d[10][10])

{
int i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
d[i][j] = w[i][j];
for (j = 0; j < n; j++)
for (i = 0; i < n; i++)
if (d[i][j] < INF)
for (k = 0; k < n; k++)
if (d[i][k] > d[i][j] + d[k][j])
d[i][k] = d[i][j] + d[k][j];
}
void main()
{
int w[10][10], n, nm, i, j, u, v,c, d[10][10];
scanf_s("%d", &n);
scanf_s("%d", &nm);
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
w[i][j] = INF;
for (i = 0; i < nm; i++)

{
scanf_s("%d", &u);
scanf_s("%d", &v);
scanf_s("%d", &c);
w[u - 1][v - 1] = w[v - 1][u - 1] = c;
}
Roy_Floyd(w, n, d);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
printf("%d ", d[i][j]);
printf("\n");
}
}
12. Yen
13. Determinare numar de arce care pleaca dintr-un nod
#include<stdio.h>
#include<conio.h>
void citire(int a[][30], int* n, int* m)
{
int x, y, i;
FILE* f;
char Numefis[30];
printf_s("\nIntroduceti fisierul: ");
gets_s(Numefis);
fopen_s(&f, Numefis, "r");
if (f == NULL)
printf_s("\nNu se poate deschide fisierul");
else
{
fscanf_s(f, "%d %d", n, m);
for (i = 0; i < *m; i++)
{
fscanf_s(f, "%d", &x);
fscanf_s(f, "%d", &y);
a[x][y] = 1;
}
fclose(f);
}
}
int numara(int a[][30], int n)

{
int i, vf, nr;
nr = 0;
printf_s("\nIntroduceti nodul: ");
scanf_s("%d", &vf);
for (i = 0; i < n; i++)
if (a[vf][i] == 1)
nr++;
return nr;
}
void main()
{
int a[30][30], m, n, rez;
citire(a, &n, &m);
rez = numara(a, n);
printf_s("\n Numarul de arce care pleaca din varful cautat este de %d", rez);
_getch();
}
14. Verificare existenta varfuri izolate
#include<stdio.h>
#include<conio.h>

{
FILE* f;
int u, v, i;
char Numefis[40];
printf_s("numele fisierului: ");
gets_s(Numefis);
if (f == NULL)
printf_s("\n Nu se poate deschide!");
else
{
for (i = 1; i <= *m; i++)
{
fscanf_s(f, "%d", &u);
fscanf_s(f, "%d", &v);
a[u][v] = a[v][u] = 1;
}
fclose(f);
}
}
int verificare(int a[][30], int n)

{
int i, ok, j;
ok = 1; //pp toate varfurile izolate
for (i = 0; i < n; i++)
for (j = 1; j < n; j++)
if (a[i][j] == 1)
ok = 0; //presupunere falsa;exista varfuri care nu sunt
izolate
if (ok == 1)
return 1; //inseamna ca toate varfurile sunt izolate
else
return 0; //nu sunt toate izolate
}
void main()
{
int a[30][30], n, m, rez;
citire(a, &n, &m);
rez = verificare(a, n);
if (rez == 0)
printf_s("\nExista varfuri care nu sunt izolate");
else
printf_s("\nToate varfurile sunt varfuri izolate");
_getch();
}
15. Verificare graf complet
#include<stdio.h>
#include<conio.h>

{
int x, y, i;
FILE* f;
char Numefis[30];
printf_s("\nIntroduceti fisierul: ");
gets_s(Numefis);
if (f == NULL)
printf_s("\nNu se poate deschide!");
else
{
for (i = 1; i <= *m; i++)
{
a[x][y] = a[y][x] = 1;
}
fclose(f);
}
}
int verifica(int a[][30], int n)

{
int i, j, ok;
ok = 1; //pp ca e complet
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if ((i != j) && a[i][j] != 1)
ok = 0; //presupunere falsa
if (ok == 1)
return 1; //graf complet
else
return 0; //graful nu e complet
}
void main()
{
int a[30][30], n, m, rez;
citire(a, &n, &m);
rez = verifica(a, n);
if (rez == 1)
printf("\nGraf complet");
else
printf("\nGraful nu e complet");
_getch();
}
16. Verificare cicluri/aciclitate

17. Algoritmul Marimont care verifica conexitate si aciclitate(verifica
daca este garf de tip arbore)
18. Kruskal
//preluare graf din fisier
#include <stdio.h>
#include <conio.h>
int radacina(int v, int tata[50])
{
int u = v;
while (tata[u] >= 0)
u = tata[u];
return u;
}
int kruskal(int a[100][3], int n)

{
int tata[50], i, j, k, p, c = 0;
for (i = 0; i < n; i++)
tata[i] = -1;
for (j = i = 0; i < n - 1; j++)
{
k = radacina(a[j][1], tata);
p = radacina(a[j][0], tata);
if (k - p)
{
if (tata[k] < tata[p])
{
tata[k] = tata[k] + tata[p];
tata[p] = k;
}
else
{
tata[p] = tata[p] + tata[k];
tata[k] = p;
}
c = c + a[j][2];
printf("\nMuchia %d - %d, cost %d", a[j][0], a[j][1], a[j][2]);
i++;
}
}
return c;
}
void main()
{
int a[100][3], n, m, cost, i, j, x, y, c, aux;
FILE* f;
f = fopen("input.txt", "r");
if (!f) printf("Eroare la deschiderea fisierului de date.");
else
{
fscanf(f, "%d", &n);
for (i = 0; i < m; i++)
{
fscanf(f, "%d", &c);
a[i][0] = x;
a[i][1] = y;
a[i][2] = c;
}
fclose(f);
}
for (i = 0; i < m - 1; i++)
for (j = i + 1; j < m; j++)
if (a[i][2] > a[j][2])
{
aux = a[i][0];
a[i][0] = a[j][0];
a[j][0] = aux;
aux = a[i][1];
a[i][1] = a[j][1];
a[j][1] = aux;
aux = a[i][2];
a[i][2] = a[j][2];
a[j][2] = aux;
}
printf("Arborele de cost minim contine muchiile: ");
cost = kruskal(a, n);
printf("\nCost total: %d", cost);
_getch();
}
//introducere graf de la tastatura, nu calculeaza

bine arborele
#include<stdio.h>
#include<conio.h>
int radacina(int v, int* tata)
{
int u = v;
while (tata[u] >= 0) u = tata[u];
return u;
}
int kruskal(int a[][3], int nv, int nm, int b[][3], int* l)// nv=numar varfuri nm=numar
muchii b retine ce am selectat, l nr de muchii selectate
{
int tata[50], i, j;
int c = 0;
*l = 0;
for (i = 0; i < nv; i++)tata[i] = -1;
for (j = i = 0; i < nv - 1; j++)
{
int v1 = a[j][0]; int v2 = a[j][1];
int k = radacina(v2, tata); int p = radacina(v1, tata);
if (k != p)
{
if (tata[k] < tata[p])
{
tata[k] += tata[p];
tata[p] = k;
}
else
{
tata[p] += tata[k];
tata[k] = p;
}
c += a[j][2];//adun costul
b[*l][0] = a[j][0];
b[*l][1] = a[j][1];
b[*l][2] = a[j][2];
(*l) = (*l) + 1;
i++;
}
}
return c;
}
void main()
{
int nv, nm, a[50][3], i, j, b[50][3];//este o forma tabelara matricea a
printf("Numarul de varfuri:"); scanf("%d", &nv);
printf("Numarul de muchii"); scanf("%d", &nm);
printf("Matricea de reprezentare\n");
for (i = 0; i < nm; i++)
{
printf("vi="); scanf("%d", &a[i][0]);
printf("vf="); scanf("%d", &a[i][1]);
printf("cost="); scanf("%d", &a[i][2]);
}
for (i = 0; i < nm; i++)
{
printf("\n");
for (j = 0; j < 3; j++)
}
printf("\nArborele de cost minim: \n");
int l = 0;
int cost = kruskal(a, nv, nm, b, &l);
printf("\ncostul=%i\n", cost);
for (i = 0; i < l; i++)
{
for (j = 0; j < 3; j++)
printf("%d ", b[i][j]);
printf("\n");
}
}
19. Prim
//introducere graf de la tastatura, nu calculeaza
bine
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
float Prim(float** w, int n, int v0, int*** arb, float MAX)

{
float cost, cmin;
int i, u, v, vf1, vf2;
cost = 0;
int* ind = (int*)malloc(n * sizeof(int));
for (i = 0; i < n; i++)
ind[i] = 0;
ind[v0 - 1] = 1;
//ind este vectorul indicator:
//ind[i]=1 daca virful i+1 a fost trecut in A, altfel este 0
int** muchii = (int**)malloc((n - 1) * sizeof(int*));
for (i = 0; i < n - 1; i++)
muchii[i] = (int*)malloc(2 * sizeof(int));
for (i = 0; i < n - 1; i++)
{
cmin = MAX;
for (u = 1; u <= n; u++)
if (ind[u - 1])
for (v = 1; v <= n; v++)
if ((!ind[v - 1]) && (w[u - 1][v - 1] <= cmin))
{
vf1 = u;
vf2 = v;
cmin = w[u - 1][v - 1];
}
cost += cmin;
muchii[i][0] = vf1;
muchii[i][1] = vf2;
ind[vf2 - 1] = 1;
}
*arb = muchii;
free(ind);
return cost;
}
void main()
{
int i, j, nv, nm, v, u, v0, ** arb; float** w, MAX = 1000000, cost, p;
//graful este preluat de la tastatura
//datele citite:numarul de virfuri, numarul de muchii si matricea ponderilor
printf("Numarul de virfuri:"); scanf("%i", &nv);
printf("Numarul de muchii:"); scanf("%i", &nm);
//alocare memorie pentru matricea ponderilor

w = (float**)malloc((nv) * sizeof(float*));
for (i = 0; i < nv; i++)
w[i] = (float*)malloc(nv * sizeof(float));
printf("Matricea ponderilor\n");
for (i = 0; i < nv; i++)
for (j = 0; j < nv; j++)
w[i][j] = MAX;
for (i = 0; i < nm; i++)
{
printf("Muchia %i si ponderea:", i + 1);
scanf("%i %i %f", &v, &u, &p);
w[u - 1][v - 1] = w[v - 1][u - 1] = p;
}
printf("Introduceti varful de pornire:");
scanf("%i", &v0);
cost = Prim(w, nv, v0, &arb, MAX);

printf("\nArborele partial de cost minim este:\n");
for (i = 0; i < nv - 1; i++)
printf("%i -> %i\n", arb[i][0], arb[i][1]);
printf(" cu costul %4.2f\n", cost);
}
//cu preluare graf din fisier text

#include <stdio.h>
#include <conio.h>
int Prim(int w[100][100], int n, int vf, int rez[100][2], int max)
{
int cost, cmin, i, u, v, v1, v2, viz[100];
cost = 0;
for (i = 0; i < n; i++)
viz[i] = 0;
viz[vf - 1] = 1;
for (i = 0; i < n - 1; i++)
{
cmin = max;
for (u = 1; u <= n; u++)
if (viz[u - 1])
for (v = 1; v <= n; v++)
if (!viz[v - 1] && w[u - 1][v - 1] <= cmin)
{
v1 = u;
v2 = v;
cmin = w[u - 1][v - 1];
}
cost = cost + cmin;
rez[i][0] = v1;
rez[i][1] = v2;
viz[v2 - 1] = 1;
}
return cost;
}
void main()
{
int w[100][100], rez[100][2], n, m, x, y, c, cost, vf, i, j;
FILE* f;
f = fopen("input.txt", "r");
if (!f) printf("Eroare la deschiderea fisierului de date.");
else
{
fscanf(f, "%d", &n);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
w[i][j] = 32000;
for (i = 0; i < m; i++)
{
fscanf(f, "%d", &c);
w[x - 1][y - 1] = w[y - 1][x - 1] = c;
}
fclose(f);
}
printf("Varful de start: ");
scanf("%d", &vf);
cost = Prim(w, n, vf, rez, 32000);
printf("Un arbore de cost minim contine muchiile: ");
for (i = 0; i < n - 1; i++)
printf("\nMuchia %d - %d", rez[i][0], rez[i][1]);
printf("\nCost total: %d", cost);
_getch();
}
20)Graf bipartit
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
#include"Coada.cpp"
#include"Preluare graf.cpp"
// Procesare virf inainte de a analiza vecinii

// I:
// E:
void proceseaza_inainte(int v, int* &rez, int &nr)
{ rez[nr++]=v;
}
// Procesare virf dupa analizarea vecinilor

// I:
// E:
void proceseaza_dupa(int v, int* &rez, int &nr)
{
}
// Procesare muchie (x,y)

// I:
// E:
void procesare_muchie(int x, int y, int* culoare, int &este)
{
//printf("\n(%2d %2d)",x,y);
if(culoare[x-1]==culoare[y-1])
{ este=0;
//printf("\nNu e graf bipartit din cauza muchiei (%2d %2d)",x,y);
}
//if(culoare[y-1]!=-1)
culoare[y-1]=!culoare[x-1];
}
// BF extins, cu prelucrare inainte/dupa si prelucrare muchii din arbore

// Determina daca un graf este bipartit
// I: virf initial (vi), graf (g)
// E: vector cu virfurile parcurse (rez), nr. virfuri parcurse (nr),
vectori culori virfuri (culoare), bipartit? (este)
void BF_E(int vi, GRAF g, int* &rez, int &nr, int* &culoare, int &este)
{ int v,i,j,ok;
TNOD *p,*u;
int* stare; //0-nedescoperit, 1-descoperit, 2-prelucrat
p=u=NULL;
stare = new int[g.n];

rez = new int[g.n];
culoare = new int[g.n];
for(i=0;i<g.n;i++)
{ stare[i]=0;
culoare[i]=-1;
}
ok=ins_c(&p,&u,vi);
stare[vi-1]=1;
culoare[vi-1]=0;
nr=0;
este=1;
while(p)
{ ok=extrage_c(&p,&u,&i);
proceseaza_inainte(i, rez, nr);
stare[i-1]=2;
for(j=0; j<g.n; j++)
if( (g.a[i-1][j] == 1) )
{ if(stare[j]!=2)
procesare_muchie(i,j+1, culoare, este);
if(stare[j]==0)
{ ok=ins_c(&p,&u,j+1);
stare[j] = 1;
}
}
}
}
void main()
{ GRAF g;
char numef[30], ponderat, orientat;
int x, er, i;
int vi, cite, *parc, *p, *c, bi;
//strcpy(numef,"Grafp.txt"); ponderat='d';
//strcpy(numef,"Graf11.txt"); ponderat='n';
strcpy(numef,"Grafa.txt"); ponderat='n';
orientat='n';
er=citire_graf(numef, g, ponderat, orientat);
if(er)
printf("\nNu pot deschide fisierul %s", numef);
else
{ printf("\nNumar virfuri: %d",g.n);
printf("\nNumar muchii: %d",g.m);
afisare_matrice(g.tab, g.m, g.p+2, "Repezentarea tabelara a

grafului:");
afisare_matrice(g.a, g.n, g.n, "Matricea de adiacenta a
grafului:");
//testare parcurgeri BF
printf_s("\nvi= ");
scanf_s("%d",&vi);
BF_E( vi, g, parc, cite, c, bi);

if(bi)
{ printf("\nGraful este bipartit: ");
printf("\n");
for(i=0;i<cite;i++)
if(c[i])
printf("%d ",i+1);
printf("\n");
for(i=0;i<cite;i++)
if(!c[i])
printf("%d ",i+1);
}
else
printf("\nGraful nu este bipartit.");
delete parc;
delete c;
dezalocare_matrice(g.a, g.n);
dezalocare_matrice(g.tab, g.m);
}
_getch();
}
21)Componenta conexa
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
#include"Coada.cpp"
// I:
// E:
{ rez[nr++]=v;
}

// I:
// E:
{
}
// Procesare virf la adaugarea din coada

// I:
// E:
void proceseaza_virf(int v, int* &rez, int &nr)
{ rez[nr++]=v;
}

// I:
// E:
void procesare_muchie(int x, int y, int** muc, int& nm)
{
//printf("\n(%2d %2d)",x,y);
muc[nm][0]=x;
muc[nm][1]=y;
nm++;
}
// BF extins, cu prelucrare inainte/dupa si prelucrare muchii din arbore

// Componenta conexa
// E: vector cu virfurile parcurse (rez), nr. virfuri parcurse (nr), lista
muchii (muc), nr. muchii (nm)
void BF_E(int vi, GRAF g, int* &rez, int &nr, int** muc, int& nm)
{ int v,i,j,ok;
TNOD *p,*u;
int* stare; //0-nedescoperit, 1-descoperit, 2-prelucrat
p=u=NULL;

rez = new int[g.n];
for(i=0;i<g.n;i++)
stare[i]=0;
ok=ins_c(&p,&u,vi);
stare[vi-1]=1;
nr=0;
while(p)
{ ok=extrage_c(&p,&u,&i);
proceseaza_inainte(i, rez, nr);
stare[i-1]=2;
if( (g.a[i-1][j] == 1) )
{ if(stare[j]!=2)
procesare_muchie(i,j+1, muc, nm);
if(stare[j]==0)
{ ok=ins_c(&p,&u,j+1);
stare[j] = 1;
}
}
}
}
void main()
{ GRAF g;
int x, er, i;
int vi, cite, *parc, *p, **muchii, nrm;
strcpy(numef,"Grafn.txt"); ponderat='n';
orientat='n';
if(er)
else

grafului:");
grafului:");
//testare parcurgeri BF
printf_s("\nvi= ");
scanf_s("%d",&vi);
muchii = new int*[g.m];

for(i=0; i<g.m; i++)
muchii[i] = new int[2];
nrm=0;
BF_E( vi, g, parc, cite, muchii, nrm);
printf("\nComponenta conexa care contine virful %d are %d virfuri si

%d muchii",vi, cite, nrm);
printf("\nVirfurile sint: ");
for(i=0; i<cite; i++)
printf("%d ",parc[i]);
printf("\nMuchiile sint: ");
for(i=0; i<nrm; i++)
printf(" (%d %d) ", muchii[i][0], muchii[i][1]);
delete parc;
dezalocare_matrice(muchii,g.m);
}
_getch();
}
22)Cicluri
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>

// I:
// E:
{ rez[nr++]=v;
}

// I:
// E:
{
}

// I:
// E:
void procesare_muchie(int x, int y, int*p, int* stare, int** muc, int& nm)
{
//printf("\n(%2d %2d)",x,y);
if(stare[y-1]==1)
if( (y!=p[x-1]) )
{ //printf("\n(%2d %2d) inapoi", x,y);
muc[nm][0]=x;
muc[nm][1]=y;
muc[nm][2]=0;
nm++;
}
else ;
else
{ //printf("\n(%2d %2d) inainte", x,y);
muc[nm][0]=x;
muc[nm][1]=y;
muc[nm][2]=1;
nm++;
}
// DF extins, cu 3 stari si prelucrarea tuturor muchiilor din componenta

conexa
// stare: 0 - nedescoperit, 1 - descoperit, 2 - prelucrat
// Clasificare muchii: 0-inapoi, 1-inainte
vector parinti (par), vector distante (dist)
void DF_E(int vi,GRAF g, int* rez, int &nr, int* par, int* stare, int**
muc, int&nm)
{ int j;
stare[vi-1]=1; //starea 2 => proceseaza doar muchiile din

arborele de parcurgere
proceseaza_inainte(vi, rez, nr);
if( (g.a[vi-1][j] == 1) )
{
if(stare[j]==0)
{ par[j] = vi;
procesare_muchie(vi,j+1,par, stare, muc, nm);
DF_E(j+1,g,rez, nr, par, stare, muc, nm);
}
else
if(stare[j]==1)
}
proceseaza_dupa(vi, rez, nr);
stare[vi-1]=2;
}
void main()
{ GRAF g;
int x, er, i;
int vi, cite, *parc, *p;
//strcpy(numef,"Grafn.txt"); ponderat='n';
strcpy(numef,"Grafa.txt"); ponderat='n';
orientat='n';
if(er)
else

grafului:");
grafului:");
//testare parcurgeri DF
int* stare;
int** muchii, nrm;
parc = new int[g.n];
p = new int[g.n];
nrm=0;
muchii=new int*[g.m];
muchii[i]=new int[3]; //coloana 3: 1-inainte, 0-inapoi
for(i=0;i<g.n;i++)
{ p[i] =-1;
stare[i]=0;
}
cite=0;
printf_s("\nvi= ");
scanf_s("%d",&vi);
DF_E(vi, g, parc, cite, p, stare, muchii, nrm);
printf("\nIncepind cu %d se parcurg in adincime: ",vi);

printf("\nMuchii analizate: ");
printf("\n(%2d %2d) - %s ", muchii[i][0], muchii[i][1],
muchii[i][2]?"Inainte":"Inapoi");
delete parc;
delete p;
delete stare;
dezalocare_matrice(muchii, g.m);
}
_getch();
}
23)Noduri articulatie
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
int t, *ti, *te;

int* sa;
int* grad;
int *na, nra;
// Adauga element in vector, daca nu e deja prezent

// I: element (x), vector (v), lungime vector (l)
// E: vector (v), lungime (l)
void adauga(int x, int *v, int &l)
{ int i, este;
este=0;
for(i=0; (i<l) && !este; i++)
if(v[i]==x)
este=1;
if(!este)
v[l++]=x;
}

// I:
// E:
{ rez[nr++]=v;
sa[v-1]=v;
grad[v-1]=0;
}

// I:
// E:
void proceseaza_dupa(int v, int* p, int n)
{ int r; //v e radacina? 0/1
int tv; //cel mai devreme moment in care poate fi accesat din
v
int tpv; //cel mai devreme moment in care poate fi accesat din
parintele lui v
if( p[v-1]<1 )
if( grad[v-1]>1 )
{ //printf("\nNod articulatie: %2d 'Radacina'",v);
adauga(v, na, nra);
}
else;
else
{ r = (p[p[v-1]-1]<1)? 1 : 0;
if( (sa[v-1]==p[v-1]) && (!r) )
{ adauga(p[v-1], na, nra);
//printf("\nNod articulatie: %2d 'Parinte'",p[v-1]);
}
if( sa[v-1]==v )
{ //printf("\nNod articulatie: %2d 'Punte'",p[v-1]);
adauga(p[v-1], na, nra);
if( grad[v-1]>0 )
{ adauga(v, na, nra);
//printf("\nNod articulatie: %2d 'Punte'",v);
}
}
tv = ti[sa[v-1]-1];
tpv= ti[sa[p[v-1]-1]-1];
if( tv<tpv )
sa[p[v-1]-1] = sa[v-1];
}
}

// I:
// E:
void procesare_muchie(int x, int y, int*p, int* stare, int** muc, int& nm)
{
//printf("\n(%2d %2d)",x,y);
//clasificare muchie
int tip=-1;
if(stare[y-1]==1)
if( (y!=p[x-1]) )
{ //printf("\n(%2d %2d) inapoi", x,y);
tip=0;
muc[nm][0]=x; muc[nm][1]=y; muc[nm][2]=tip; nm++;
}
else ;
else
{ //printf("\n(%2d %2d) inainte", x,y);
tip=1;
muc[nm][0]=x; muc[nm][1]=y; muc[nm][2]=tip; nm++;
}
//utilizare clasa muchie: actualizare grad sau stramos accesibil
if( tip==1 )
grad[x-1]++ ;
if( (tip==0) && (p[x-1]!=y) )
if( ti[y-1] < ti[sa[x-1]-1] )
sa[x-1] = y;
}

conexa
// Gasire noduri articulatie
void DF_E(int vi,GRAF g, int* rez, int &nr, int* par, int* stare, int**
muc, int&nm)
{ int j;

t=t+1;
ti[vi-1]=t;
proceseaza_inainte(vi, rez, nr);
if( (g.a[vi-1][j] == 1) )
{
if(stare[j]==0)
{ par[j] = vi;
DF_E(j+1,g,rez, nr, par, stare, muc, nm);
}
else
if(stare[j]==1)
}
proceseaza_dupa(vi, par, g.n);
stare[vi-1]=2;
t=t+1;
te[vi-1]=t;
}
void main()
{ GRAF g;
int x, er, i;
int vi, cite, *parc, *p;
//strcpy(numef,"Grafa.txt"); ponderat='n';
strcpy(numef,"Grafart.txt"); ponderat='n';
orientat='n';
if(er)
else

grafului:");
grafului:");
int* stare;
int** muchii, nrm;
p = new int[g.n];
nrm=0;
muchii[i]=new int[3]; //coloana 3: 1-inainte, 0-inapoi
for(i=0;i<g.n;i++)
{ p[i] =-1;
stare[i]=0;
}
cite=0;
printf_s("\nvi= ");
scanf_s("%d",&vi);
t=0;
sa=new int[g.n]; //stramos accesibil
grad=new int[g.n]; //grad extern in arborele de parcurgere (nr fii)
ti=new int[g.n]; //moment incepere prelucrare nod
te=new int[g.n]; //moment terminare prelucrare nod
na=new int[g.n]; //noduri articulatie
nra=0;
DF_E(vi, g, parc, cite, p, stare, muchii, nrm);
printf("\nIncepind cu %d se parcurg in adincime: ",vi);

printf("\nMuchii analizate: ");
printf("\n(%2d %2d) - %s ", muchii[i][0], muchii[i][1],
muchii[i][2]?"Inainte":"Inapoi");
printf("\nAm gasit %d virfuri articulatie: ", nra);
for(i=0; i<nra; i++)
printf("%d ",na[i]);
delete parc;
delete p;
delete stare;
delete sa;
delete grad;
delete ti;
delete te;
delete na;
}
_getch();
}
23)Sortare topologica
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
int t, *ti, *te;

int* sa;
int* grad;
int *na, nra;
int** muchii, nrm;
// Afisare drum din vectorul de parinti obtinut in urma parcurgerii

gradului
// I: virf final (v), parinti (p), numar noduri (n)
// E: -
void cale(int v,int *p, int n)
{ if(v!=-1)
{ cale(p[v-1],p,n);
printf("%d ",v);
}
}
// Adauga element in vector, daca nu e deja prezent

// I: element (x), vector (v), lungime vector (l)
// E: vector (v), lungime (l)
void adauga(int x, int *v, int &l)
{ int i, este;
este=0;
for(i=0; (i<l) && !este; i++)
if(v[i]==x)
este=1;
if(!este)
v[l++]=x;
}
// Clasificare muchie
// I: virf inceput (x), virf sfirsit (y), vector parinti (p), vector stare
(stare), vector moment intrare (ti - global), nr. virfuri (n)
// E: cod (-1-neclasificata, 0-inapoi, 1-arbore, 2-inainte, 3-lateral)
int tip_muchie(int x, int y, int* p, int *stare, int n)
{ int t;
t=-1;
if( p[y-1]==x )
t=1;
else
if( stare[y-1]==1 )
t=0;
else
if( stare[y-1]==2 && ti[y-1]>ti[x-1] )
t=2;
else
if( stare[y-1]==2 && ti[y-1]<ti[x-1] )
t=3;
return t;
}

// I:
// E:
{
}

// I:
// E:
{ rez[nr++]=v;
}

// I:
// E:
void procesare_muchie(int x, int y, int*p, int* stare, int n, int &este)
{
//printf("\n(%2d %2d)",x,y);
//clasificare muchie
int tip;
tip=tip_muchie(x, y, p, stare, n);
if( tip==0 )
este=0;
muchii[nrm][0]=x;
muchii[nrm][1]=y;
muchii[nrm][2]=tip;
nrm++;
}

conexa
// Gasire noduri articulatie
void DF_E(int vi,GRAF g, int* rez, int &nr, int* par, int* stare, int
&este)
{ int j;

t=t+1;
ti[vi-1]=t;
if( (g.a[vi-1][j] == 1) )
{
if(stare[j]==0)
{ par[j] = vi;
procesare_muchie(vi,j+1, par, stare, g.n, este);
DF_E(j+1,g,rez, nr, par, stare, este);
}
else
//if(stare[j]==1)
procesare_muchie(vi,j+1,par, stare, g.n, este);
}
proceseaza_dupa(vi, rez, nr);
stare[vi-1]=2;
t=t+1;
}
void main()
{ GRAF g;
int x, er, i;
int vi, cite, *parc, *p, este;
orientat='n';
//strcpy(numef,"Grafa.txt"); ponderat='n';
//strcpy(numef,"Grafart.txt"); ponderat='n';
strcpy(numef,"Grafo.txt"); ponderat='n'; orientat='d';
if(er)
else

grafului:");
grafului:");
int* stare;

p = new int[g.n];
nrm=0;
muchii[i]=new int[3];
for(i=0;i<g.n;i++)
{ p[i] =-1;
stare[i]=0;
}
cite=0;
printf_s("\nvi= ");
scanf_s("%d",&vi);
t=0;
ti=new int[g.n]; //moment incepere prelucrare nod
este=1;
for(i=0; i<g.n; i++)

if(stare[i]==0)
DF_E(i+1, g, parc, cite, p, stare, este);
if( este )
{ printf("\nSortare topologica: ");
for(i=cite-1; i>=0; i--)
}
else
printf("\nGraful are cicluri, nu se poate face sortarea!");
for(i=0;i<nrm;i++)
switch(muchii[i][2])
{ case 0: printf("\n(%2d %2d) - inapoi",
muchii[i][0],muchii[i][1]); break;
case 1: printf("\n(%2d %2d) - arbore",
case 2: printf("\n(%2d %2d) - inainte",
case 3: printf("\n(%2d %2d) - lateral",
default: printf("\n(%2d %2d) - necunoscut",
muchii[i][0],muchii[i][1]);
}
delete parc;
delete p;
delete stare;
delete ti;
}
_getch();
23)Coada
#include<stdio.h>
#include<malloc.h>
//tipul nod pentru coada

typedef struct nod
{ int inf;
struct nod *next;
} TNOD;
//adaugare informatie in coada

//I: prim, ultim, informatie
//E: prim, ultim, cod succes
int ins_c(TNOD** prim,TNOD** ultim,int info)
{ TNOD* p;
int ok;
if(p=(TNOD*)malloc(sizeof(TNOD)))
{ p->inf=info;
p->next=NULL;
if(*prim==NULL)
*prim=p;
else
(*ultim)->next=p;
*ultim=p;
ok=1;
}
else
ok=0;
return ok;
}
//extragere informatie din coada

//I: prim, ultim
//E: prim, ultim, informatie, cod succes
int extrage_c(TNOD** prim,TNOD** ultim, int *info)
{ TNOD* p;
int ok;
if(*prim)
{ p=*prim;
*info=(*prim)->inf;
(*prim)=(*prim)->next;
free(p);
if(*prim==NULL)
*ultim=NULL;
ok=1;
}
else
ok=0;
return ok;
}
1. Problema rucsacului
b.Continua
#include<stdio.h>
#include<conio.h>
//problema rucsacului, continua
// I: capacitate totala (q), nr. obiecte (n), capacitate ocupata (c), cistig (v)
// E: solutia x (x[i]= raportul in care e incarcat obiectul i)
void Rucsac_c(float q, int n, float* c, float* x)
{
float qr;
int i, j;
qr = q;
for (i = 0; i < n && qr>0; i++)
if (qr >= c[i])
{
x[i] = 1;
qr -= c[i];
}
else
{
x[i] = qr / c[i];
qr = 0;
for (j = i + 1; j < n; j++)
x[j] = 0;
}
}
void main()
{
float cap_totala;
printf("Introduceti capacitatea rucsacului:");
scanf("%f", &cap_totala);
int n;
int i;
printf("Introduceti numarul de obiecte:");
scanf("%d", &n);
float c[50], v[50];
printf("Introduceti capacitatile specifice obiectelor:\n");
for (i = 0; i < n; i++)
{
printf("c[%d]=", i);
scanf("%f", &c[i]);
}
printf("Introduceti catigul specific obiectelor:\n");
for (int i = 0; i < n; i++)
{
printf("v[%d]=", i);
scanf("%f", &v[i]);
}
//float CT = 33; //capacitate totala de transport
//float c[10] = { 1,2,3,4,5,6,7,8,9,10 }; //capacitati
//float v[10] = { 3,2,1,4,5,3,2,7,1,8 }; //venituri
//pentru cazul general datele de intrare se vor citi de la tastatura
float sol[50], a, castig;
int j;
//prelucrare preliminara
//sortarea obiectelor
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (v[i] / c[i] < v[j] / c[j]) //cistig unitar
{
a = v[i]; v[i] = v[j]; v[j] = a;
a = c[i]; c[i] = c[j]; c[j] = a;
}
//apel functie
Rucsac_c(cap_totala, n, c, sol);
//afisare rezultate
castig = 0;
for (i = 0; i < n; i++)
{
printf("\n%2d: c=%5.2f v=%5.2f %2f, cistig=%5.2f", i + 1, c[i], v[i],
sol[i], castig += v[i] * sol[i]);
}
_getch();
a.Intreaga
#include<stdio.h>
#include<conio.h>
//problema rucsacului, intreaga

// I: capacitate totala (q), nr. obiecte (n), capacitate ocupata (c), cistig (v)
// E: solutia x (x[i]= 0-obiectul i nu e incarcat, 1-obiectul i e incarcat)
void Rucsac_i(float q, int n, float c[], int x[])
{
float qr;
int i;
qr = q; //capacitatea ramasa disponibila, initial capacitatea totala

for (i = 0; i < n; i++)
if (qr >= c[i])
{
x[i] = 1;
qr -= c[i];
}
else
x[i] = 0;
}
void main()
{
float cap_totala;
printf("Introduceti capacitatea rucsacului:");
scanf("%f", &cap_totala);
int n;
int i;
printf("Introduceti numarul de obiecte:");
scanf("%d", &n);
float c[50], v[50];
printf("Introduceti capacitatile specifice obiectelor:\n");
for (i = 0; i < n; i++)
{
printf("c[%d]=", i);
scanf("%f", &c[i]);
}
printf("Introduceti catigul specific obiectelor:\n");
for (int i = 0; i < n; i++)
{
scanf("%f", &v[i]);
}
//float CT = 33; //capacitate totala de transport

//float c[N] = { 1,2,3,4,5,6,7,8,9,10 }; //capacitati
//float v[N] = { 3,2,1,4,5,3,2,7,1,8 }; //venituri
////pentru cazul general datele de intrare se vor citi de la tastatura
int sol[50]; float castig, a;

int j;
//prelucrare preliminara
//sortarea obiectelor
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (v[i] / c[i] < v[j] / c[j]) //cistig unitar
{
a = v[i]; v[i] = v[j]; v[j] = a;
a = c[i]; c[i] = c[j]; c[j] = a;
}
//apel functie
Rucsac_i(cap_totala, n, c, sol);
//afisare rezultate
castig = 0;
for (i = 0; i < n; i++)
{
printf("\n%2d: c=%5.2f v=%5.2f %2d, cistig=%5.2f", i + 1, c[i], v[i],
sol[i], castig += v[i] * sol[i]);
}
_getch();
}
2. Suma maxima dintr-o multime de numere naturale
#include<stdio.h>
#include<conio.h>
// Submultimea care da suma maxima: se iau doar elementele (strict) pozitive

// I: multimea (a), numar de elemente (n)
// E: submultimea (b), numar de elemente (nr)
void suma_maxima(float* a, int n, float* b, int* nr)

{
int i;
*nr = 0;
for (i = 0; i < n; i++)
if (a[i] >= 0) // = pentru zero, care nu afecteaza suma.
b[(*nr)++] = a[i];
}
void main()
{
float a[100], b[100];
int n, i, nr;
printf("Introduceti numarul de elemente:");
scanf("%d", &n);
printf("Elementele sunt:\n");
for (i = 0; i < n; i++)
{
printf("a[%d]=", i);
scanf("%f", &a[i]);
}
suma_maxima(a, n, b, &nr);
if (nr == 0)
printf("Nu exista numare pozitive");
else
{
printf("Solutia este:");
for (i = 0; i < nr; i++)
printf("%f ", b[i]);
}
}
3. Plata unei sume cu bancnota unitara

#include<stdio.h>
#include<conio.h>
// Plata unei sume, cu bancnota unitate, cu numar minim de bancnote

// I: suma (s), tipuri bancnote (t), numar tipuri (n)
// E: nr. din fiecare tip
void plata_unitate(int s, int* t, int n, int* sol)
{
int i, sr;
sr = s;
for (i = 0; i < n; i++)
{
sol[i] = sr / t[i];
sr = sr % t[i];
}
}
void sortare(int x[], int n)

{
int i, j, aux;
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (x[i] < x[j])
{
aux = x[i];
x[i] = x[j];
x[j] = aux;
}
}
void main()
{
int t[100], sol[100], suma, n, i;
printf("Introduceti numarul de tipuri de bancnote:");
scanf("%d", &n);
printf("Introduceti valoare fiecarei bancnote:\n");
for (i = 0; i < n; i++)
{
printf("t[%d]=", i);
scanf("%d", &t[i]);
}
printf("Introduceti suma de plata:");
scanf("%d", &suma);
sortare(t, n);
plata_unitate(suma, t, n, sol);
for (i = 0; i < n; i++)
printf("%d bancnote de %d \n", sol[i], t[i]);
4. Problema paznicului (determinare nr de pomi dintr o

pozitie)
#include<stdio.h>
#include<math.h>
int cmmdc(int a, int b)
{
int r;
while (b != 0)
{
r = a % b;
a = b;
b = r;
}
if (a == 1)
return 1;
else
return 0;
}
int pomi(int m, int n, int x, int y)

{
int i, j, nr;
nr = 0;
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
nr = nr + (cmmdc((fabs(x - i)), (fabs(y - j))) == 1);
return nr;
}
void main()
{
int m, n, x, y, nr;
printf("Introduceti dimensiuni livada: \n");
printf("m="); scanf("%d", &m);
printf("n="); scanf("%d", &n);
printf("Introduceti coordonatele in care se afla paznicul: \n");
printf("x="); scanf("%d", &x);
printf("y="); scanf("%d", &y);
nr = pomi(m - 1, n - 1, x - 1, y - 1);
printf("Paznicul vede %d pomi", nr);
}
//determinare cati pomi vede din fiecare pozitie
#include <stdio.h>
#include <conio.h>
#include <math.h>
int cmmdc(int a, int b)

{
int r;
while (b)
{
r = a % b;
a = b;
b = r;
}
return a;
}
int paznic(int m, int n, int x, int y)

{
int i, j, nr;
nr = 0;
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
nr = nr + (cmmdc(abs(x - i), abs(y - j)) == 1);
return nr;
}
void main()
{
int m, n, i, j, k, x[100][100];
printf("m= ");
scanf_s("%d", &m);
printf("n= ");
scanf_s("%d", &n);
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
x[i][j] = paznic(m, n, i, j);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
printf("%2d ", x[i][j]);
printf("\n");
}
_getch();
}
5. Problema spectacolelor
#include <stdio.h>
int inceput[20], sfarsit[20], nr[20], n;
void sortare_spectacole()
{
int schimb, aux, i;
do {
schimb = 0;
for (i = 0; i < n - 1; i++)
if (sfarsit[nr[i]] > sfarsit[nr[i + 1]]) {
aux = nr[i];
nr[i] = nr[i + 1];
nr[i + 1] = aux;
schimb = 1;
}
} while (schimb);
}
void main()
{
int i, h, m, ultim;
printf("Numarul de spectacole: "); scanf_s("%d", &n);
printf("Introduceti ora de inceput si de sfarsit a fiecarui spectacol: ");
for (i = 0; i < n; i++)
{
nr[i] = i;
printf("\nIntervalul de timp pt spectacolul %d\n", i);
printf("Ora inceput: "); scanf_s("%d", &h);
printf("Minut: "); scanf_s("%d", &m);
inceput[i] = h * 60 + m;
printf("Ora sfarsit: "); scanf_s("%d", &h);
printf("Minut: "); scanf_s("%d", &m);
sfarsit[i] = h * 60 + m;
}
sortare_spectacole();
printf("\nSpectacolele selectate sunt: %d ", nr[0]);
for (ultim = 0, i = 1; i < n; i++)
if (inceput[nr[i]] >= sfarsit[nr[ultim]]) {
printf("%d ", nr[i]);
ultim = i;
}
}
6. Interclasarea optima a n vectori

#include<stdio.h>
#include<conio.h>
typedef struct {
int* a;
int l;
}VECTOR;
void interclasare(int v1[100], int l1, int v2[100], int l2, int vr[200], int* lr)
{
int i, j, k;
i = j = *lr = 0;
while (i < l1 && j < l2)
if (v1[i] < v2[j]) vr[(*lr)++] = v1[i++];
else vr[(*lr)++] = v2[j++];
for (k = i; i < l1; k++)
vr[(*lr)++] = v1[k];
for (k = j; k < l2; k++)
vr[(*lr)++] = v2[k];
}
void interclasare_optima(VECTOR l[100], int n)

{
int i, j, k, nr, t, aux, ok, vr[200], lr;
int* d;
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++)
if (l[i].l > l[j].l)
{
d = l[i].a;
l[i].a = l[j].a;
l[j].a = d;
aux = l[i].l;
l[i].l = l[j].l;
l[j].l = aux;
}
nr = n;
for (i = 0; i < n - 1; i++)
{
interclasare(l[0].a, l[0].l, l[1].a, l[1].l, vr, &lr);
for (j = 2; j < n; j++)
{
l[j - 2].a = l[j].a;
l[j - 2].l = l[j].l;
}
n = n - 2;
for (j = 0; j < n && l[j].l < lr; j++);
for (k = n; k > j; k--)
{
l[k].a = l[k - 1].a;
l[k].l = l[k - 1].l;
}
l[j].a = vr;
l[j].l = lr;
n++;
}
}
void main()
{
VECTOR l[100];
int i, n, j;
printf("Numar de vectori: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
printf("Vectorul %d", i + 1);
printf(" Dimensiunea lui este: ");
scanf("%d", &l[i].l);
printf("\nVector: ");
for (j = 0; j < l[i].l; j++)
scanf("%d", &l[i].a);
}
interclasare_optima(l, n);
printf("Vector rezultat:\n");
}
7. Determinarea unui produs de transpozitii

#include <stdio.h>
#include <conio.h>
void produs(int p[100], int n, int i, int j)

{
int t[100], r[100], k;
for (k = 1; k <= n; k++)
t[k] = k;
t[i] = j;
t[j] = i;
for (k = 1; k <= n; k++)
r[k] = t[p[k]];
for (k = 1; k <= n; k++)
p[k] = r[k];
}
void descompunere_perm(int p[100], int n, int s[2][100], int* nr)

{
int i, pt[100];
for (i = 1; i <= n; i++)
pt[i] = p[i];
*nr = 0;
for (i = 1; i <= n - 1; i++)
{
if (pt[i] != i)
{
s[0][*nr] = i;
s[1][*nr] = pt[i];
(*nr)++;
produs(pt, n, i, pt[i]);
}
}
}
void main()
{
int p[100], n, s[2][100], i, nr;
printf("Dimensiune: ");
scanf("%d", &n);
printf("Permutare: \n");
for (i = 1; i <= n; i++) printf("%d ", i);
printf("\n");
for (i = 1; i <= n; i++) scanf("%d", &p[i]);
descompunere_perm(p, n, s, &nr);
for (i = nr - 1; i >= 0; i--)
printf("%d %d\n", s[0][i], s[1][i]);
_getch();
}
8. Dijkstra la grafuri
9. Kruskal & prim la grafuri
10. Determinarea celui mai mic numar natural avand k

divizori naturali proprii
#include <stdio.h>
int verificare(int n, int k)

{
int i, d = 0;
for (i = 2; i <= n / 2; i++)
if (n % i == 0)d++;
int r = (d == k) ? 1 : 0;
return r;
}
int divizori(int k)
{
int i, n;
n = k + 2;
while (verificare(n, k) == 0)n++;
return n;
}
void main()
{
int k;
printf("Introduceti nr. de divizori proprii:");
scanf_s("%d", &k);
printf("Cel mai mic nr. natural cu %d divizori proprii este %d\n", k,
divizori(k));
}
RECURSIVITATE
1. Sortarea prin metoda bulelor
#include<stdio.h>
void sortare_bule(float v[], int nr)
{
int i, gata;
float aux;
gata = 0;
for (i = 0; i < nr - 1; i++)
{
if (v[i] > v[i + 1])
{
aux = v[i];
v[i] = v[i + 1];
v[i + 1] = aux;
gata = 1;
}
}
if (gata == 1)
sortare_bule(v, nr);
}
void main()
{
float v[50];
int nr, i;
printf("Numarul de elemente ale vectorului:");
scanf_s("%d", &nr);
printf("Introduceti elementele vectorului:\n");
for (i = 0; i < nr; i++)
scanf_s("%f", &v[i]);
sortare_bule(v, nr);
printf("Vector sortat:");
for (i = 0; i < nr; i++)
printf("%f ", v[i]);
}
2. Suma elementelor unui vector-recursiva

//Nu returneaza nimic
#include<stdio.h>
void suma_vector(float v[], int nr, float *suma)
{
if (nr == 0)
*suma = 0;
else
{
suma_vector(v, nr - 1, suma);
*suma = *suma + v[nr - 1];
}
}
void main()
{
float v[50], suma;
int nr, i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
suma = 0;
suma_vector(v, nr, &suma);
printf("Suma elementelor vectorului este:%f", suma);
}
//Returnare prin parametru

#include<stdio.h>
float suma_vector(float v[], int nr)
{
float suma;
if (nr == 0)
suma = 0;
else
suma = v[nr - 1] + suma_vector(v, nr - 1);
return suma;
}
void main()
{
float v[50], sum;
int nr, i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
sum = suma_vector(v, nr);
printf("Suma elementelor vectorului este: %f", sum);
}
3. Produsul elementelor unui vector

//Nu returneaza nimic
#include<stdio.h>
void produs_vector(float v[], int nr, float* produs)
{
if (nr == 0)
*produs = 1;
else
{
produs_vector(v, nr - 1, produs);
*produs = *produs * v[nr - 1];
}
}
void main()
{
float v[50], produs;
int nr, i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
produs = 1;
produs_vector(v, nr, &produs);
printf("Produsul elementelor vectorului este: %f", produs);
4. Calculul combinărilor de n luate câte k

5. #include<stdio.h>
6. int combinari(unsigned n, unsigned k)
7. {
8. unsigned c;
9. if (n < k)
10. c = 0;
11. else
12. {
13. if (k == 0 || k == n)
14. c = 1;
15. else
16. c = combinari(n - 1, k - 1) + combinari(n - 1, k);
17. }
18. return c;
19. }
20. void main()
21. {
22. unsigned n, k, comb;
23. printf("Introduceti n:");
24. scanf_s("%u", &n);
25. printf("Introduceti k:");
26. scanf_s("%u", &k);
27. comb=combinari(n, k);
28. printf("Combinari de %u luate cate %u = %u", n, k, comb);}
5) Sa se determine numărul de elemente negative dintr-un vector

utilizand o functie recursiva.
#include<stdio.h>
int numere_negative(float v[], int nr)
{
int nr_neg;
if (nr == 0)
nr_neg = 0;
else
{
nr_neg = numere_negative(v, nr - 1);
if (v[nr - 1] < 0)
nr_neg = nr_neg + 1;
}
return nr_neg;
}
void main()
{
float v[50];
int nr,nr_negg, i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
nr_negg = numere_negative(v, nr);
printf("Numarul de numere negative din vector este:%d", nr_negg);
6) Produsul scalar dintre doi vectori recursiv

#include<stdio.h>
float produs_scalar(float* a, float* b, int nr)
{
float ps;
if (nr == 0)
ps = 0;
else
ps = a[nr - 1] * b[nr - 1] + produs_scalar(a, b, nr - 1);
return ps;
}
void main()
{
float a[50], b[50];
int nr,i;
float prod_scalar;
scanf_s("%d", &nr);
printf("Introduceti elementele vectorului a:\n");
for (i = 0; i < nr; i++)
scanf_s("%f", &a[i]);
printf("Introduceti elementele vectorului b:\n");
for (i = 0; i < nr; i++)
scanf_s("%f", &b[i]);
prod_scalar = produs_scalar(a, b, nr);
printf("Produsul scalar dintre cei doi vectori este:%f", prod_scalar);
}
7)CMMDC recursiv + prin scaderi repetate

#include<stdio.h>
int cmmdc(int nr1, int nr2)
{
int CMMDC;
if (nr1 % nr2==0)
return nr2;
else
return cmmdc(nr2, nr1 % nr2);
}
void main()
{
int nr1, nr2;
int rezultat;
printf("Introduceti primul numar:");
scanf_s("%d", &nr1);
printf("Introduceti al doilea numar:");
scanf_s("%d", &nr2);
rezultat = cmmdc(nr1, nr2);
printf("CMMDC dintre cele doua numere este:%d", rezultat);
}
Scaderi repetate:
int cmmdc (int a, int b)
{if (a==b)
return a;
else
if (a>b)
return cmmdc((a-b), b);
else
return cmmdc(a, (b-a));
}
void main()
{
int a, b;
printf("a=");
scanf("%d", &a);
printf("b=");
scanf("%d", &b);
printf("Cmmdc este: %d", cmmdc(a, b));
printf("Cmmmc este: %d", ((a*b)/cmmdc(a,b)));
}
8) Maximul dintr-un vector

#include<stdio.h>
float maxim(float v[], int nr)
{
float max;
if (nr == 0)
return v[nr];
else
{
max = maxim(v, nr - 1);
if (max > v[nr - 1])
return max;
else
return v[nr - 1];
}
}
void main()
{
float v[50];
float rezultat;
int nr, i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
rezultat = maxim(v, nr);
printf("Maximul din vector este: %f", rezultat);
9) Aranjamente
#include<stdio.h>
int aranjamente(int n, int k)
{
int a;
if (k > n)
return 0;
else
{
if (k == 1)
return n;
else
{
a = n * aranjamente(n - 1, k - 1);
return a;
}
}
}
void main()
{
int n, k;
int aranj;
printf("Introduceti n:");
scanf_s("%d", &n);
printf("Introduceti k:");
scanf_s("%d", &k);
aranj = aranjamente(n, k);
printf("Aranjamente de %d luate cate %d=%d", n, k, aranj);
10) Metoda bisectiei

#include <stdio.h>
float ecuatie(float x)
{
return x * x - 4* x + 4;
}
int bisectie(float x1, float x2,float eps, int n,float (*f)(float),float* x)
{
int cod = 0;
while ((n > 0) && (cod == 0))
{
*x = (x1 + x2) / 2;
if ((*f)(*x) == 0)
cod = 1;
else
if ((x2 - x1) < eps)
cod = 2;
else
if ((*f)(x1)*(*f)(*x) < 0)
x2 = *x;
else
x1 = *x;
n--;
}
return cod;
}
void main()
{
float a, b, sol, prec;
int nr, cod;
printf("\na="); scanf("%f", &a);
printf("\nb="); scanf("%f", &b);
printf("\nprecizia=");
scanf("%f", &prec);
printf("\nnr="); scanf("%d", &nr);
cod = bisectie(a, b, prec, nr, ecuatie, &sol);
switch (cod)
{
case 0: printf("\nFara solutie");
break;
case 1: printf("\nSolutia exacta este % 7.3f", sol);
break;
case 2: printf("\nSolutia aproximativa este % 7.3f", sol);
}
}
11) Cautare binara

#include<stdio.h>
int cautare_binara(float v[], int ls, int ld, float k)
{
int mij;
if (ls > ld)
mij = -1;
else
{
mij = (ls + ld) / 2;
if (k < v[mij])
mij = cautare_binara(v, ls, mij - 1, k);
else
{
if (k > v[mij])
mij = cautare_binara(v, mij + 1, ld, k);
}
}
return mij;
}
void main()
{
float v[50];
int ls, ld;
float k;
int poz;
int nr,i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
printf("Introduceti elementul cautat:");
scanf_s("%f", &k);
ls = 0;
ld = nr;
poz = cautare_binara(v, ls, ld, k);
printf("Pozitia pe care apare elementul cautat este: %d", poz);
12) Ackermann
#include<stdio.h>
int ackermann(int m, int n)
{
if (m == 0)
return n + 1;
else
{
if (n == 0)
return ackermann(m - 1, 1);
}
return ackermann(m - 1, ackermann(m, n - 1));
}
void main()
{
int m, n;
printf("Introduceti m");
scanf_s("%d", &m);
printf("Introduceti n");
scanf_s("%d", &n);
int rezultat;
rezultat = ackermann(m, n);
printf("\n%d", rezultat);
}
13)Fibonacci
#include<stdio.h>
#include<conio.h>
#include<math.h>
int fib(int n)
{
int f;
if (n == 0)
return 0;
else
{
if (n == 1)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
}
void main()
{
int n, f;
printf("Vreau termenul de pe pozitia: ");
scanf_s("%d", &n);
f = fib(n - 1);
printf("Termenul %d din sirul lui Fibonaci este: %d", n, f);
_getch();
}
14) Hannoi
#include<stdio.h>
void turnuri_hanoi(int n, int a, int b, int c)
{
if (n > 0)
{
turnuri_hanoi(n - 1, a, c, b);
printf("muta un disc de pe %d pe %d\n", a, c);
turnuri_hanoi(n - 1, b, a, c);
}
}
int main()
{
int a, b, c, n;
a = 1; b = 2; c = 3;
printf("nr discuri ");
scanf_s("%d", &n);
turnuri_hanoi(n, a, b, c);
}
15) Calulul temenilor de rang impar

#include<stdio.h>
int rang(float v[], int nr)
{
int nr_rang_impar;
if (nr == 0)
nr_rang_impar = 0;
else
{
nr_rang_impar = rang(v, nr - 1);
if ((nr - 1) % 2 == 1)
nr_rang_impar = nr_rang_impar + 1;
}
return nr_rang_impar;
}
void main()
{
float v[50];
int nr, nr_imp, i;
scanf_s("%d", &nr);
for (i = 0; i < nr; i++)
nr_imp = rang(v, nr);
printf("Numarul de elemente de rang impar este: %d", nr_imp);
}
16) Suma cifrelor unui numar

#include<stdio.h>
int suma_cifrelor(int n)
{
if (n == 0)
return 0;
else
return suma_cifrelor(n / 10) + n % 10;
}
void main()
{
int n;
int suma;
printf("Introduceti numarul:");
scanf_s("%d", &n);
suma = suma_cifrelor(n);
printf("Suma cifrelor numarului %d este:%d", n, suma);
}
17)Calcul termen de rang n din siruri diferite

#include<stdio.h>
float alfa, beta, gama, delta, a0, b0;
float sirb(int);
float sira(int n)
{
if (n == 0)
return a0;
else
return alfa * sira(n - 1) + delta * sirb(n - 1);
}
float sirb(int n)
{
if (n == 0)
return b0;
else
return gama * sira(n - 1) + delta * sirb(n - 1);
}
void main()
{
float alfa, beta, gama, delta, a0, b0;
printf("Introduceti alfa");
scanf_s("%f", &alfa);
printf("Introduceti beta");
scanf_s("%f", &beta);
printf("Introduceti delta");
scanf_s("%f", &delta);
printf("Introduceti gama");
scanf_s("%f", &gama);
printf("Introduceti a0");
scanf_s("%f", &a0);
printf("Introduceti b0");
scanf_s("%f", &b0);
float rezultat_sira, rezultat_sirb;
int n;
printf("Calculeaza termin de rang:");
scanf_s("%d", &n);
rezultat_sira = sira(n);
rezultat_sirb = sirb(n);
printf("Rezultat sira: %f Rezultat sirb: %f", rezultat_sira,rezultat_sirb);
18)Calcul polinom de grad n intr-un punct

#include<stdio.h>
//P(x) = a[n] * putere(x, n) + a[n - 1] * putere(x, n - 1) + ... + a[o]
float putere(float x, int n)
{
float p;
if (n == 0) p = 1;
else p = x * putere(x, n - 1);
return p;
}
float polinom(float a[100], int n, float x)
{
if (n == 0)
return a[0];
else
return a[n] * putere(x, n) + polinom(a, n - 1, x);
}
void main()
{
float x, a[100];
float p;
int n, i;
printf("x=");
scanf_s("%f", &x);
printf("n=");
scanf_s("%d", &n);
for (i = 0; i < n + 1; i++)
{
printf("a[%d]=", i);
scanf_s("%f", &a[i]);
}
p = polinom(a, n, x);
printf("\n");
printf("Valoarea polinomului in punctul %5.2f este %5.2lf", x, p);
}
19)Functia HERMITE
#include<stdio.h>
int Hermite(int n, int x)

{
if (n == 0)
return 1;
else
{
if (n == 1)
return 2 * x;
else
{
if (n > 1)
return 2 * n * Hermite(n - 1, x) - 2 * (n - 1) * Hermite(n -
2, x);
}
}
}
int main()
{
int rezultat;
int n, x;
long h;
printf("x=");
scanf_s("%d", &x);
printf("Gradul polinomului:");
scanf_s("%d", &n);
rezultat = Hermite(n, x);
printf("%d", rezultat);
}
20) Maxim dintr-un sir cu divide et impera

#include<stdio.h>
float maxim(float a[100], int s, int d)

{
float x1, x2;
if (s == d)
return a[s];
else
{
x1 = maxim(a, s, (s + d) / 2);
x2 = maxim(a, (s + d) / 2 + 1, d);
if (x1 > x2)
return x1;
else
return x2;
}
}
void main()
{
int i, n;
float v[100];
float max;
printf("Nr elemente:");
scanf_s("%d", &n);
printf("Elemente:\n");
for(i=0;i<n;i++)
max = maxim(v, 0, n - 1);
printf("Nr maxim este=%f", max);
}
21) Cautare in vector nesortat

#include<stdio.h>
int cautare(float v[100], int i, int n, float val)
{
int pozitie;
if (i == n)
pozitie = -1;
else
{
if (val == v[i])
pozitie = i;
else
pozitie = cautare(v, i + 1, n, val);
}
return pozitie;
}
void main()
{
float v[100];
float val;
int i, n;
scanf_s("%d", &n);
for (i = 0; i < n; i++)
scanf_s("%f", &val);
int p;
i = 0;
p = cautare(v, i, n, val);
printf("Elementul cautat se afla pe pozitia %d", p);
}
22)Prima aparitie a unei valori cautate intr-un

vector
#include<stdio.h>
int prima_pozitie(float v[], int i, int n, float val)
{
int poz;
if ((i == n) || (val< v[i]))
poz = -1;
else
{
if (val == v[i])
poz = i;
else
poz = prima_pozitie(v, i + 1, n, val);
}
return poz;
}
void main()
{
float v[100];
float val;
int i, n;
scanf_s("%d", &n);
for (i = 0; i < n; i++)
int p;
i = 0;
p =prima_pozitie(v, i, n, val);
printf("Prima aparitie a elementului cautat este pe pozitia:%d", p);
}
23) Ultima aparitie

#include<stdio.h>
int prima_pozitie(float v[], int i, int n, float val)
{
int poz;
if ((i == n))
poz = -1;
else
{
if (val == v[i])
poz = i;
else
poz = prima_pozitie(v, i,n-1, val);
}
return poz;
}
void main()
{
float v[100];
float val;
int i, n;
scanf_s("%d", &n);
for (i = 0; i < n; i++)
int p;
i = n-1;
p =prima_pozitie(v, i, n, val);
printf("Ultima Aparitie a elementului cautat este pe pozitia:%d", p);
}
24) Ridicare matrice la putere

#include <stdio.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void citireMatrice(int a[20][20], int* n) {

int i, j;
printf("Numarul de linii & coloane: "); scanf("%d", &(*n));
for (i = 0; i < *n; i++) {
for (j = 0; j < *n; j++) {
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
void afisareMatrice(int a[20][20], int n) {

int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf(" %d ", a[i][j]);
}
puts(" ");
}
}
void putereMatrice(int a[20][20], int n, int p) {

// 
int i, j, q, k, c[20][20];
int b[20][20];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
b[i][j] = (i == j);
}
} // 
puts("Afisarea matricei unitate...");

for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf(" %d ", b[i][j]);
}
puts(" ");
}
for (q = 0; q < p; q++) {

for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
c[i][j] = 0;
for (k = 0; k < n; k++)
c[i][j] = c[i][j] + b[i][k] * a[k][j];
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
b[i][j] = c[i][j];
}
printf("Afisarea matricea ridicata la puterea %d \n", p);

for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf(" %d ", b[i][j]);
}
puts(" ");
}
void main() {
int a[20][20];
int i, j, n, p;
citireMatrice(a, &n);
afisareMatrice(a, n);
printf("Puterea este: "); scanf("%d", &p);
putereMatrice(a, n, p);
}
SORTARI
1)Interclasare
#include<stdio.h>
void interclasare1(float v[], int ls, int m, int ld)

{
int i, j, k;
float v1[100];
for (i = ls, j = m + 1, k = 0; i <= m && j <= ld; k++)
if (v[i] < v[j])
{
v1[k] = v[i];
i = i + 1;
}
else
{
v1[k] = v[j];
j = j + 1;
}
while (i <= m)
v1[k++] = v[i++];
while (j <= ld)
v1[k++] = v[j++];
for (i = 0; i < k; i++)v[ls + i] = v1[i];
}
void interclasare2(float v[], int ls, int ld)

{
int mij;
if (ls < ld)
{
mij = (ld + ls) / 2;
interclasare2(v, ls, mij);
interclasare2(v, mij + 1, ld);
interclasare1(v, ls, mij, ld);
}
}
void main()
{
int n, i;
float v[100];
printf("Numarul de elemente din vector:");
scanf_s("%d", &n);
printf("Elementele din vector:");
for (i = 0; i < n; i++)
{
}
interclasare2(v, 0, n - 1);
printf("\nVectorul sortat:");
for (i = 0; i < n; i++)
}
2) Insertie
#include<stdio.h>
void sortare(int a[100], int n)

{
int aux, i, j;
for (i = 0; i < n - 1; i++)
{
aux = a[i];
j = i - 1;
while (j >= 0 && a[j] > aux)
{
a[j + 1] = a[j];
j = j - 1;
}
a[j + 1] = aux;
}
}
int main()
{
int a[100], n, i;
printf("Numar de elemente vector:");
scanf_s("%d", &n);
printf("Elementele vectorului:\n");
for (i = 0; i < n; i++)
scanf_s("%d", &a[i]);
sortare(a, n);
printf("vector sortat \n");
for (i = 0; i < n; i++)
printf("%d ", a[i]);
}
3)HEAP
#include<stdio.h>
int stanga(int i)
{
return 2 * i + 1;
}
int dreapta(int i)
{
return 2 * i + 2;
}
void aranjare_heap(double* H, int i, int n)

{
int s, d, max;
s = stanga(i);
d = dreapta(i);
if ((s < n) && (H[s] > H[i]))max = s;
else max = i;
if ((d < n) && (H[d] > H[max]))
max = d;
if (max != i) {
double aux = H[i];
H[i] = H[max];
H[max] = aux;
aranjare_heap(H, max, n);
}
}
void construire_heap(double* H, int n)
{
int i;
for (i = n / 2; i >= 0; i--)
aranjare_heap(H, i, n);
}
void heap_sort(double* H, int n)

{
int i;
construire_heap(H, n);
for (i = n - 1; i >= 1; i--) {
double aux = H[i];
H[i] = H[0];
H[0] = aux;
aranjare_heap(H, 0, i);
}
}
void main()
{
int n, i; double x[100];
printf("Inroduceti numarul de elemente n=");
scanf_s("%d", &n);
printf("Elementele:");
for (i = 0; i < n; i++)
{
printf("x[%d]=", i);
scanf_s("%lf", &x[i]);
}
heap_sort(x, n);
for (i = 0; i < n; i++)
printf("%3.1lf ", x[i]);
}
4)Selectie
#include<stdio.h>
void sortare_selectie(float v[], int l)

{
int i, j;
int aux;
for (i = 0; i < l - 1; i++)
{
for (j = i + 1; j < l; j++)
if (v[j] < v[i])
{
aux = v[i];
v[i] = v[j];
v[j] = aux;
}
}
}
void main()
{
float v[20];
int n, i;
printf("Numar de elemente din vector:");
scanf_s("%d", &n);
printf("Elemente vector: \n");
for (i = 0; i < n; i++)
sortare_selectie(v, n);
printf("Vector sortat\n");
for (i = 0; i < n; i++)
}
5) Sortare rapida quicksort

#include<stdio.h>
int poz(float* x, int p, int u)
{
int i, j, l, di, dj;
float v;
i = p; j = u; di = 0; dj = -1;
while (i < j)
if (x[i] > x[j])
{
v = x[i]; x[i] = x[j]; x[j] = v;
l = di; di = -dj; dj = -l;
i += di; j += dj;
}
else
{
i += di; j += dj;
}
return i;
}
void quick(float* x, int p, int u)

{
int i;
if (p < u)
{
i = poz(x, p, u);
quick(x, p, i - 1);
quick(x, i + 1, u);
}
}
void main()
{
int n, i;
float v[50];
printf("Dimensiunea vectorului:");
scanf_s("%d", &n);
printf("Elementele vectorului\n");
for (i = 0; i < n; i++)
{
}
quick(v, 0, n - 1);
printf("Vectorul sortat\n");
for (i = 0; i < n; i++)
}
6) Sortare prin numarare

#include<stdio.h>
#include<malloc.h>
void sortare_numarare(float v[], int l)
{
int i, j, * num;
float* temp;
temp = (float*)malloc(l * sizeof(float));
num = (int*)malloc(l * sizeof(int));
for (i = 0; i < l; i++)
num[i] = 0;
for (i = 0; i < l - 1; i++)
for (j = i + 1; j < l; j++)
if (v[j] < v[i])
num[i]++;
else num[j]++;
for (i = 0; i < l; i++)
temp[num[i]] = v[i];
for (i = 0; i < l; i++)

v[i] = temp[i];
free(temp);
free(num);
}
void main()
{
int n, i;
float x[100];
scanf_s("%d", &n);
printf("Elementele vectorului:\n");
for (i = 0; i < n; i++)
{
printf("x[%d]=", i);
scanf_s("%f", &x[i]);
}
sortare_numarare(x, n);
printf("Vector sortat:\n");
for (i = 0; i < n; i++)
printf("%f ", x[i]);
}
7) Metoda sortarii prin micsorarea icrementului

SORTAREA SHELL
#include<stdio.h>
void sortare_shell(float v[], int l)
{
int i, j, inc;
float a;
for (inc = l / 2; inc > 0; inc = inc / 2)
for (i = inc; i < l; i++)
for (j = i - inc; (j >= 0) && (v[j] > v[j + inc]); j = j - inc)
{
a = v[j];
v[j] = v[j + inc];
v[j + inc] = a;
}
}
void main()
{
int n, i;
float v[1000];
scanf_s("%d", &n);
printf("Elemente vector:\n");
for (i = 0; i < n; i++)
{
}
sortare_shell(v, n);
printf("Vectorul sortat\n");
for (i = 0; i < n; i++)
}
ALTE PROGRAME GASITE
1)Frecventa de aparitia valori intr-un vector

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi, dimensiunea vectorului, numarul de

valori distincte din vector.
//E - adresa masivului cu valorile distincte ale masivului de intrare
int* detValUniceVector (int* pv, int n, int *m)

{ int *pu;
*m=0;
pu=(int*)malloc(n*sizeof(int));
for(int i=0; i<n; i++)
{ int vb=0;
for(int j=0;j<n;j++)
if(*(pv+i)==*(pu+j))
vb=1;
if(!vb)
{ *(pu+*m)=*(pv+i);
*m=*m+1;
}
}
int *puN;
puN=(int*)malloc(*m*sizeof(int));
for(int i=0; i<*m;i++)
*(puN+i)=*(pu+i);
free(pu);
return puN;
}
//I - vectorul cu valori intregi, dimensiunea vectorului, vectorul cu

valorile distincte ale vectorului de intrare, vectorul cu frecventele de
aparitie, numarul de valori distincte identificate in vectorul de intrare.
//E - frecventele de aparitie sunt calculate in locatiile vectorului de
frecvente.
void calculFrecvente(int* pv, int n, int* pu, int* pf, int m)

{ for(int i=0;i<m;i++)
for(int j=0; j<n;j++)
if(*(pu+i)==*(pv+j))
*(pf+i)=*(pf+i)+1;
}
void main()
{
int n, *pv, i;
printf("Introduceti dimensiunea vectorului:");
scanf("%d",&n);
pv=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d",pv+i);
}
int m, *pu;
pu=detValUniceVector(pv,n,&m);
int *pf;
pf=(int*)malloc(m*sizeof(int));
for(i=0;i<m;i++)
*(pf+i)=0;
calculFrecvente(pv, n, pu, pf, m);
for(i=0;i<m;i++)
printf("\nValoarea %d are frecventa de aparitie %d", *(pu+i),
*(pf+i));
free(pv);
free(pu);
free(pf);
getch();
}
2)Inserarea valoare nula pe pozitia anterioara

fiecarei valori negative
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi, dimensiunea vectorului de intrare.

//E - numarul de valori negative din vectorul de intrare
int calcululNrNegative(int* pv, int n)

{ int m=0;
for(int i=0;i<n;i++)
if(*(pv+i)<0)
m=m+1;
return m;
}
//I - vectorul de intrare cu valori intregi, lungimea vectorului de
intrare, vectorul construit prin inserarea de valori nule
//E - elementele noului vector prin suprascrierea locatiilor rezervate in
vectorul rezultat transmis ca parametru de intrare
void inserareNule (int* pv, int n, int*pf)

{ int j=0;
{ if(*(pv+i)<0)
{ *(pf+j)=0;
j=j+1;
}
*(pf+j)=*(pv+i);
j=j+1;
}
}
void main()
{ int n, *pv,i;
scanf("%d",&n);
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d",pv+i);
}
int ng;
ng=calcululNrNegative(pv,n);
int m=n+ng;
int *pf=(int*)malloc(m*sizeof(int));
inserareNule(pv,n,pf);
printf("\n");
for(i=0;i<m;i++)
printf("%d",*(pf+i));
free(pv);
free(pf);
getch();
}
3)Stergere valori duplicate

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi, dimensiunea vectorului de intrare.

//E - numarul de valori negative din vectorul de intrare
int calcululNrNegative(int* pv, int n)

{ int m=0;
if(*(pv+i)<0)
m=m+1;
return m;
}

intrare, vectorul construit prin inserarea de valori nule
//E - elementele noului vector prin suprascrierea locatiilor rezervate in
vectorul rezultat transmis ca parametru de intrare
void inserareNule (int* pv, int n, int*pf)
{ int j=0;
{ if(*(pv+i)<0)
{ *(pf+j)=0;
j=j+1;
}
*(pf+j)=*(pv+i);
j=j+1;
}
}
void main()
{ int n, *pv,i;
scanf("%d",&n);
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d",pv+i);
}
int ng;
ng=calcululNrNegative(pv,n);
int m=n+ng;
int *pf=(int*)malloc(m*sizeof(int));
inserareNule(pv,n,pf);
printf("\n");
for(i=0;i<m;i++)
printf("%d",*(pf+i));
free(pv);
free(pf);
getch();
}
4)Concatenare vectori
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu adresele masivelor care se concateneaza, vectorul de

lungimi ale masivelor de intrare, numarul de masive care se concateneaza,
lungimea vectorului obtinut prin concatenarea masivelor de intrare
//E - vectorul creat pentru stocarea masivelor concatenate
int* Concateneaza(int** pv, int*pn, int n, int* m)

{ int i,j,k=0;
*m=0;
for(i=0;i<n;i++)
*m=*m+*(pn+i);
int *pc=(int*)malloc(*m*sizeof(int));
for(i=0;i<n;i++)
for(j=0;j<*(pn+i);j++)
{ *(pc+k)=*(*(pv+i)+j);
k=k+1;
}
return pc;
}
void main()
{ int n, *pn, **pv, i;
printf("Introduceti numarul de vectori:");
scanf("%d",&n);
pn=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{printf("Dimensiune vector %d:", i+1);
scanf("%d",pn+i);
}
pv=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
*(pv+i)=(int*)malloc(*(pn+i)*(sizeof(int)));
for(i=0;i<n;i++)
{ printf("\nIntroduceti elementele vectorului %d:\n",i+1);
for(int j=0;j<*(pn+i);j++)
{ printf("v%d[%d]=", i+1,j+1);
scanf("%d", *(pv+i)+j);
}
}
int m;
int *pm=Concateneaza(pv, pn, n, &m);
printf("\n");
for(i=0;i<m;i++)
printf(" %d ", *(pm+i));
for(i=0;i<n;i++)
free(*(pv+i));
free(pv);
free(pn);
free(pm);
getch();
}
5)Produsul a doi vectori
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - masivele de intrare ale operatiei produs vectorial, lungimile

masivelor de intrare
//E - masivul cu valorile aferente produsului vectorial
int* PV(int* pv, int*pu, int n)

{ int i, *pw;
pw=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
*(pw+i)=*(pv+i)**(pu+i);
return pw;
}
void main()
{ int *pv, *pu, i,m,n;
printf("Introduceti dimensiunea vectorului 1:");

scanf("%d",&m);
scanf("%d",&n);
if(m==n)
{
pv=(int*)malloc(m*sizeof(int));
pu=(int*)malloc(n*sizeof(int));
for(i=0;i<m;i++)
{ printf("v1[%d]=", i+1);
scanf("%d", pv+i);
}
printf("\n");
for(i=0;i<n;i++)
{ printf("v2[%d]=", i+1);
scanf("%d", pu+i);
}
int* pp=PV(pv,pu,n);
printf("\n");
for(i=0;i<n;i++)
printf(" %d ", *(pp+i));
free(pv);
free(pu);
free(pp);
}
else
printf("\nDimensiunile vectorilor nu permit efectuarea
operatiei!\n");
getch();
6)Interclasarea a 2 vectori
#include<conio.h>
#include<stdio.h>
#include<malloc.h>
//I - vectorul cu valori intregi care se sorteaza, lungimea vectorului

sortat
//E - nu se construieste o structura separata, vectorul de intrare avand
elementele sortate
void sortare(int* pv, int m)

{ for(int i=0;i<m-1;i++)
for(int j=i+1; j<m; j++)
if(*(pv+i)>*(pv+j))
{ int aux=*(pv+i);
*(pv+i)=*(pv+j);
*(pv+j)=aux;
}
}
void main()
{ int m,n,*px,*py,i,j,k;

scanf("%d",&m);
px=(int*)malloc(m*sizeof(int));
for(i=0;i<m;i++)
{ printf("v1[%d]=", i+1);
scanf("%d",px+i);
}

scanf("%d",&n);
py=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{ printf("v2[%d]=", i+1);
scanf("%d",py+i);
}
sortare(px,m);
sortare(py,n);
int *pi=(int*)malloc((m+n)*sizeof(int));
k=0;
i=0;
j=0;
while(i<m && j<n)

{ if(*(px+i) < *(py+j))
{ *(pi+k)=*(px+i);
i=i+1;
}
else
{*(pi+k)=*(py+j);
j=j+1;
}
k=k+1;
}
if(i<m)
for(int ii=i;ii<m;ii++)
{ *(pi+k)=*(px+ii);
k=k+1;
}
else
for(int jj=j;jj<n;jj++)
{ *(pi+k)=*(py+jj);
k=k+1;
}
printf("\n");
for(i=0;i<k;i++)
printf(" %d ", *(pi+i));
free(px);
free(py);
free(pi);
getch();
}
7)Aflarea codului ASCII

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#include<
void main()
{
char *src=NULL, *token=NULL;

char sep[]=".,";
int n=100;
src=(char*)malloc((n+1)*sizeof(char));
memset(src, 0X00,n+1);
printf("Introduceti sirul de caractere:");
scanf(" %s ", src);
token=strtok(src,sep);
char *pCuv[51];
int i=0;
while(token)
{ pCuv[i]=(char*)malloc(sizeof(char)*strlen(token)+1);
strcpy(pCuv[i],toke);
i=i+1;
token=strtok(NULL,sep);
}
printf("\n");
for(int j=0; j<i; j++)
printf("\n%s", pCuv[j]);
free(src);
for(int j=0; j<i; j++)
free(pCuv[j]);
getch();
}
8)Aflarea valorilor strict pozitive

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi pentru care se aplica operatia, lungimea

vectorului de intrare
//E - numarul de elemente strict pozitive din vectorul de intrare
int nrPozitive(int* pv, int n)

{ int m=0;
for(int i=0; i<n; i++)
if( *(pv+i)>0)
m=m+1;
return m;
}
intrare, lungimea noului vector determinata in cadrul functiei
//E - noua zona de memorie dinamica aferenta masivului cu valori intregi
strict pozitive
int* extragerePoz(int* pv, int n, int *m)

{ *m=nrPozitive(pv,n);
int* pp=(int*)malloc(n*sizeof(int));
int i, j=0;
for(i=0;i<n;i++)
if(*(pv+i)>0)
{ *(pp+j)=*(pv+i);
j=j+1;
}
return pp;
}
void main()
{ int n, *pv, i;
scanf("%d",&n);
for(i=0;i<n;i++)
{ printf("v[%d]=",i+1);
scanf("%d", pv+i);
}
int m;
int *pz=extragerePoz(pv,n,&m);
for(i=0;i<m;i++)
printf(" %d ", *(pz+i));
free(pv);
free(pz);
getch();
}
9)Identitatea multimilor
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul baza de comparare, vectorul comparat, vectorul

indicatorilor de stare, lungimile celor doi vectori
//E - valoarea semafor de identitate a celor doi vector
int verificaIdentitatea(float* px, float* py, int* ps, int m, int n)

{ int i,j,vb=0;
for(i=0;i<m;i++)
{ int vbs=0;
for(j=0;j<n;j++)
if(*(px+i)==*(py+j))
{ *(ps+j)=1;
vbs=1;
}
if(!vbs)
vb=1;
}
if(vb)
return 0;
else
for(i=0;i<n;i++)
if(!*(ps+i))
return 0;
return 1;
}
void main()
{ int m,n,i;
float *px, *py;
scanf("%d", &m);
px=(float*)malloc(m*sizeof(float));
for(i=0;i<m;i++)
{printf("v1[%d]=",i+1);
scanf("%f", px+i);
}

scanf("%d", &n);
py=(float*)malloc(n*sizeof(float));
for(i=0;i<n;i++)
{printf("v2[%d]=",i+1);
scanf("%f",py+i);
}
int *pis=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
*(pis+i)=0;
int vb=verificaIdentitatea(px,py,pis,m,n);
if(vb)
printf("\nVectorii sunt identici!");
else
printf("\nVectorii contin multimi diferite de valori!");
free(px);
free(py);
free(pis);
getch();
10)Deconcatenarea masivului
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi alocat in memoria dinamica, lungimea

vectorului
//E - suma valorilor stocate in vectorul de intrare
int suma(int* ps,int n)
{int s=0;
s=s+*(ps+i);
return s;
}
int main()
{int n,i;
float* pv;
printf("Introduceti Dimensiune Vector:");
scanf("%d",&n);
pv=(float*)malloc(n*sizeof(float));
for(i=0;i<n;i++)
{printf("v[%d]=",i+1);
scanf("%f",pv+i);
}
int m,*pl;
printf("Introduceti nr de puncte de rupere:");
scanf("%d",&m);
pl=(int*)malloc((m+1)*sizeof(int));
int pct=0;
for(i=0;i<m;i++)
{printf("\nPunctul %d:",i+1);
scanf("%d",&pct);
if(!i)
*pl=pct;
else
*(pl+i)=pct-suma(pl,i);
}
*(pl+m)=n-pct;
float** pd;
pd=(float**)malloc((m+1)*sizeof(float*));
*pd=(float*)malloc(*pl*sizeof(float));
for(i=1;i<=m;i++)
*(pd+i)=(float*)malloc(*(pl+i)*sizeof(float));
i=0;
for(int j=0;j<=m;j++)
for(int k=0;k<*(pl+j);k++)
{*(*(pd+j)+k)=*(pv+i);
i=i+1;
}
for(i=0;i<=m;i++)
{printf("\nElemente vector %d:\n",i+1);
for(int j=0;j<*(pl+i);j++)
printf("%f",*(*(pd+i)+j));
}
free(pv);
free(pl);
for(i=0;i<=m;i++)
free(*(pd+i));
free(pd);
getch();
}
11)Matrice patratica cu valori constante
#include<conio.h>
#include<stdio.h>
#include<malloc.h>
int main()
{int **pm,n,i,j;
printf("Dimensiunea Matricei:");
scanf("%d",&n);
pm=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
*(pm+i)=(int*)malloc(n*sizeof(int));
int c;
printf("Valoare constantei:");
scanf("%d",&c);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(j==i || j==n-i-1)
*(*(pm+i)+j)=c;
else
*(*(pm+i)+j)=0;
for(i=0;i<n;i++)
{printf("\n");
for(j=0;j<n;j++)
printf("%d",*(*(pm+i)+j));
}
for(i=0;i<n;i++)
free(*(pm+i));
free(pm);
getch();
}
12)Liniarizarea lexicografica
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
int main()
{int **pm,m,n,i,j;
printf("Introduceti nr de linii:");
scanf("%d",&m);
printf("Introduceti nr de coloane:");
scanf("%d",&n);
pm=(int**)malloc(m*sizeof(int*));
for(i=0;i<m;i++)
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("M[%d][%d]=",i+1,j+1);
scanf("%d",*(pm+i)+j);
}
int *pv,nr,k;
nr=m*n;
pv=(int*)malloc(nr*sizeof(int));
k=0;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{*(pv+k)=*(*(pm+i)+j);
k=k+1;
}
printf("\n");
for(i=0;i<nr;i++)
printf("%d",*(pv+i));
for(i=0;i<m;i++)
free(*(pm+i));
free(pm);
free(pv);
getch();
}
13)Suma a doua matrici
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - doua matrice cu valor reale, dimensiunea celor doua matrice data in
numar de linii si coloane
//E - adresa de memorie dinamica pentru gestionarea matricei rezultat
float** sumaMat(float **pa, float **pb, int m, int n)

{float **suma;
int i,j;
suma=(float**)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(suma+i)=(float*)malloc(n*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
*(*(suma+i)+j)=*(*(pa+i)+j)+*(*(pb+i)+j);
return suma;
}
void main() {
float **pa, **pb;
int m,n,p,r,i,j;
printf("Introduceti numarul de linii matrice A:");
scanf("%d",&m);
printf("Introduceti numarul de coloane matrice A:");
scanf("%d",&n);
printf("Introduceti numarul de linii matrice B:");

scanf("%d",&p);
printf("Introduceti numarul de coloane matrice B:");
scanf("%d",&r);
if(m==p && n==r)

{ pa=(float **)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(pa+i)=(float*)malloc(n*sizeof(float));
pb=(float**)malloc(p*sizeof(float*));
for(i=0;i<p;i++)
*(pb+i)=(float*)malloc(r*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("A[%d][%d]=", i+1,j+1);
scanf("%f",*(pa+i)+j);
}
for(i=0;i<p;i++)
for(j=0;j<r;j++)
{printf("B[%d][%d]=", i+1,j+1);
scanf("%f",*(pb+i)+j);
}
float **ps;
ps=sumaMat(pa,pb,m,n);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf(" %7.2f ", *(*(ps+i)+j));
}
for(i=0;i<m;i++)
free(*(pa+i));
free(pa);
for(i=0;i<m;i++)
free(*(pb+i));
free(pb);
for(i=0;i<m;i++)
free(*(ps+i));
free(ps);
}
else
printf("\nOperatia nu poate fi efectata");
getch();
}
14)Transpusa
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - matricea pentru care se determina transpusa, matricea rezultat cu

valorile transpuse, dimensiunea celor doua matrice data in numar de linii
si coloane
//E - valorile transpuse ale matricei sunt plasate in memoria dinamica pe
baza adresei matricei rezultat transmisa catre functie in lista de
parametri
void transpusaMat (float **pm, float **pt, int m, int n)
{ for (int i=0; i<m;i++)
for(int j=0; j<n;j++)
*(*(pt+j)+i)=*(*(pm+i)+j);
}
void main()
{ float **pm;
int m,n,i,j;
printf("Introduceti numarul de linii:");
scanf("%d",&m);
printf("\nIntroduceti numarul de coloane:");
scanf("%d",&n);
pm=(float**)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(pm+i)=(float*)malloc(n*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{printf("M[%d][%d]=", i+1,j+1);
scanf("%f", *(pm+i)+j);
}
float **pt;
pt=(float**)malloc(n*sizeof(float*));
for(i=0;i<n;i++)
*(pt+i)=(float*)malloc(m*sizeof(float));
transpusaMat(pm,pt,m,n);
for(i=0;i<n;i++)
{printf("\n");
for(j=0;j<m;j++)
printf(" %7.2f ", *(*(pt+i)+j));
}
for(i=0;i<m;i++)
free(*(pm+i));
free(pm);
for(i=0;i<m;i++)
free(*(pt+i));
free(pt);
getch();
}
15)Modificarea structurii prin linii
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//I - vectorul cu valori intregi care se sorteaza crescator, numarul de

valori din vector
//E - sirul ordonat de valori accesibil in zona de memorie dinamica
aferenta vectorului
void sortareVector(int *pv, int n)

{ for(int i=0;i<n-1;i++)
for(int j=i+1;j<n;j++)
if(*(pv+i)>*(pv+j))
{ int aux=*(pv+i);
*(pv+i)=*(pv+j);
*(pv+j)=aux;
}
}
//I - vectorul cu valori intregi sortate crescator, numarul de linii care
se insereaza, numarul de linii din matricea care isi modifica structura
//E - indicator de validare: valoarea 0 pentru vector invalid, valoarea 1
pentru vector valid
int validarePozitii(int *pv, int n,int m)

{ int *pis;
pis=(int*)malloc(n*sizeof(int));
*(pis+i)=0;
for(int i=0;i<n-1;i++)
for(int j=i+1; j<n;j++)
if(*(pv+i)==*(pv+j))
*(pis+i)=*(pis+j)=1;
if(*(pis+i))
{free(pis);
return 0;
}
*(pis+i)=0;
if(*(pv+i)>m+n)
*(pis+i)=1;
if(*(pis+i))
{ free(pis);
return 0;
}
free(pis);
return 1;
}
void main()
{ float **pm;
int m,n,i,j;
printf("Introduceti numarul de linii al matricei: ");
scanf("%d",&m);
printf("Introduceti numarul de coloane al matricei: ");
scanf("%d",&n);
pm=(float**)malloc(m*sizeof(float*));
for(i=0;i<m;i++)
*(pm+i)=(float*)malloc(n*sizeof(float));
for(i=0;i<m;i++)
for(j=0;j<n;j++)
{ printf("M[%d][%d]=", i+1, j+1);
scanf("%f", *(pm+i)+j);
}
float **pr;
int *pv;
int r;
printf("Introduceti numarul de linii suplimentare:");
scanf("%d",&r);
pv=(int*)malloc(r*sizeof(int));
printf("Introduceti pozitiile in matricea rezultat pentru liniile de
inserat:\n");
for(i=0;i<r;i++)
{ printf("Linia %d:", i+1);
scanf("%d",pv+i);
}
sortareVector(pv,r);
int vb=validarePozitii(pv,r,m);
if(vb)
{ pr=(float**)malloc((m+r)*sizeof(float*));
for(i=0;i<m+r;i++)
*(pr+i)=(float*)malloc(n*sizeof(float));
int k=0, pmi=0;
for(i=0; i<m+r; i++)

if(i==*(pv+k)-1)
{ for(j=0;j<n;j++)
*(*(pr+i)+j)=0;
k=k+1;
}
else
{ for(j=0;j<n;j++)
*(*(pr+i)+j)=*(*(pm+pmi)+j);
pmi=pmi+1;
}
for(i=0;i<m;i++)
free(*(pm+i));
free(pm);
pm=pr;
pr=NULL;
for(i=0;i<m+r;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf(" %7.2f ", *(*(pm+i)+j));
}
}
else
printf("\nVectorul de pozitii ale liniilor nu este corect
specificat!\n");
for(i=0;i<m+r;i++)
free(*(pm+i));
free(pm);
free(pv);
getch();
}
16)Suma elementelor de sub diagonala
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
int sumasec(int **pm,int n)
{int i,j,s=0;
for(i=1;i<n;i++)
for(j=n-1;j>n-i-1;j--)
s=s+*(*(pm+i)+j);
return s;
}
int main()
{int **pm=NULL , n,i,j;
printf("Dimensiune Matrice:");
scanf("%d",&n);
pm=(int**)malloc(n*sizeof(int*));
for(i=0;i<n;i++)
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{printf("M[%d][%d]=",i+1,j+1);
scanf("%d",*(pm+i)+j);
}
for(i=0;i<n;i++)
{printf("\n");
for(j=0;j<n;j++)
printf("%d",*(*(pm+i)+j));
}
printf("\nSuma elementelor de sub diagonala secundara este
%d:\n",sumasec(pm,n));
for(i=0;i<n;i++)
if(*(pm+i))
free(*(pm+i));
if(pm)
free(pm);
getch();
}
MULTE ALTE PROBLEME GASITE PE ORIUNDE
1)Generare aranjamente
#include<stdio.h>
#include<conio.h>
// Verifica daca valoarea elementului i este acceptabila (diferita de cele

anterioare)
int posibil( int* v, int i)
{ int j, r;
r=1;
for(j=0;j<i;j++)
if(v[i]==v[j])
r=0;
return r;
}
// Afisare solutie pe ecran

void retine_solutia(int num, int nr, int* v)
{ int i;
printf("\n\n Solutia numarul %d\n",num);

for(i=0; i<nr; i++)
printf("%2d ",v[i]);
// Genereaza aranjamente de n elemente (1..n) luate cite k

// I: n, k
// E: numar aranjamente
int aranjamente(int n, int k)
{ int* p,i,am,nr;
// pentru ca se foloseste un vector de dimensiune n, cu indici de la 0

la n-1 (in loc de 1..n)
// indicele i arata o configuratie solutie daca i==k-1, configuratie
finala daca i=-1
p=new int[n]; //vectorul solutie

nr=0; //numar solutii
i=0;
p[0]=0; //prima valoare minus ratia
while(i>=0) //cit timp nu am ajuns la configuratia finala
{ am=0;
while( p[i]<n && !am) //alege urmatoarea valoare acceptabila pentru
x[i]
{ p[i]++; //urmatoarea valoare pentru x[i]
am=posibil(p,i); //este acceptabila?
}
if(!am) //impas, revenire
i--;
else
if( i==k-1 ) //configuratie solutie
retine_solutia(++nr,k,p);
else
p[++i]=0; //prima valoare minus ratia
}
delete p;
return nr;
}
void main()
{ int n,k,nr;
printf("\nGenereaza aranjamente de n elemente. n= ");

scanf("%d",&n);
printf("\nluate cite k. k= ");
scanf("%d",&k);
nr=aranjamente(n,k);
printf("\n\n Sint %d aranjamente posibile",nr);
printf("\n\nGata. Apasa o tasta.");

_getch();
}
2)Generare combinari
#include<stdio.h>
#include<conio.h>
// Verifica daca valoarea elementului i este acceptabila (diferita de cele

anterioare)
int posibil( int* v, int i)
{ int j, r;
r=1;
for(j=0;j<i;j++)
if(v[i]==v[j])
r=0;
return r;
}
// Afisare solutie pe ecran

void retine_solutia(int num, int nr, int* v)
{ int i;
printf("\n\n Solutia numarul %d\n",num);

for(i=0; i<nr; i++)
printf("%2d ",v[i]);
// Genereaza combinari de n elemente (1..n) luate cite k

// I: n, k
// E: numar combinari
int combinari(int n, int k)
{ int* p,i,am,nr;
// pentru ca se foloseste un vector de dimensiune n, cu indici de la 0

la n-1 (in loc de 1..n)
// indicele i arata o configuratie solutie daca i==k-1, configuratie
finala daca i=-1
p=new int[n]; //vectorul solutie

nr=0; //numar solutii
i=0;
p[0]=0; //prima valoare minus ratia
while(i>=0) //cit timp nu am ajuns la configuratia finala
{ am=0;
while( p[i]<n && !am) //alege urmatoarea valoare acceptabila pentru
x[i]
{ p[i]++; //urmatoarea valoare pentru x[i]
am=posibil(p,i); //este acceptabila?
}
if(!am) //impas, revenire
i--;
else
if( i==k-1 ) //configuratie solutie
retine_solutia(++nr,k,p);
else
p[++i]=p[i-1]; //se initializeaza cu valoarea elementului
anterior => generare in ordine lexicografica
}
delete p;
return nr;
}
void main()
{ int n,k,nr;
printf("\nGenereaza combinari de n elemente. n= ");

scanf("%d",&n);
printf("\nluate cite k. k= ");
scanf("%d",&k);
nr=combinari(n,k);
printf("\n\n Sint %d combinari posibile",nr);
printf("\n\nGata. Apasa o tasta.");

_getch();
}
3)Matrice distante
#include<stdio.h>
#include<conio.h>
#define INF 1000
void citire ( int a[][30], int *n, int *m)

{
int x,y,z,i,j;
FILE* f;
char Numefis[30];
printf_s("\nNume fisier: ");
gets_s(Numefis);
fopen_s(&f,Numefis,"r");
if(f==NULL)
printf_s("\nNu se poate deschide fisierul!");
else
{
fscanf_s(f, "%d %d", n,m);
for(i=1;i<=*n;i++)
for(j=1;j<=*n;j++)
if(i==j)
a[i][j]=0;
else
a[i][j]=INF;
for(i=1;i<=*m;i++)
{
fscanf_s(f, "%d", &z);
a[x][y]=a[y][x]=z;
}
fclose(f);
}
}
void Roy_Floid(int a[][30], int n, int d[][30])

{
int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
d[i][j]=a[i][j];
for(j=0;j<n;j++)
for(i=0;i<n;i++)
if(d[i][j] < INF)
for(k=0;k<n;k++)
if(d[i][k] > d[i][j]+d[j][k])
d[i][k] = d[i][j]+d[j][k];
}
void main()
{
int a[30][30],m,n,i,j;
int d[30][30];
citire(a,&n,&m);
Roy_Floid(a,n,d);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf_s("%d ", d[i][j]);
printf_s("\n");
}
_getch();
}
PROBLEME MARIAH
1.Scrieți un subprogram recursiv care determină maximul de pe pozițiile pare dintre un

vector, folosind metoda Divide et Impera precum și programul principal (funcția main)
care demonstrează utilizarea acestui subprogram. Transmiterea datelor se va realiza
exclusiv prin parametri. Elementele vectorului sunt indexate de la 0.
Incărcați codul sursă (realizat conform cerințelor problemei și programării

structurate) și print screen de la momentul execuției din care să reiasă rularea
corectă.
Exemplu de test: vectorul v={6,5,8,10,4} cu n=5 elemente.
(imi da max=8)
Rezolvare in C facuta de mine:
#define _CRT_SECURE_NO_WARNINGS_
#include<stdio.h>
int maxim(int* pare, int s, int d)
int a, b, m;
if (s == d)
return pare[s];
else
m = (s + d) / 2;
a = maxim(pare, s, m);
b = maxim(pare, m + 1, d);
if (a > b)
return a;
else
return b;
int main()
int i, * v, * pare, n;
printf ("dati numarul de valori din vector") ;
scanf_s("%d", &n);
v = new int[n];
printf( "dati elementele din vector" );
for (i = 0; i < n; i++)
scanf_s("%d", &v[i]);
if (n % 2 == 0) pare = new int[n / 2];
else pare = new int[(n / 2) + 1];
for (i = 0; i < n; i = i + 2)
pare[i] = v[i];
int maxi = maxim(pare, 0, n - 1);
printf( "Maximul este: %d", maxi);

}
Rezolvare in C++:
#include<iostream>
using namespace std;
int maxim(int* pare, int s, int d)
int a, b, m;
if (s == d)
return pare[s];
else
m = (s + d) / 2;
a = maxim(pare, s, m);
b = maxim(pare, m + 1, d);
if (a > b)
return a;
else
return b;
int main()
int i, * v, * pare, n;
cout << "dati numarul de valori din vector" << endl;

cin >> n;
v = new int[n];
cout << "dati elementele din vector" << endl;
for (i = 0; i < n; i++)
cin >> v[i];
if (n % 2 == 0) pare = new int[n / 2];
else pare = new int[(n / 2) + 1];
for (i = 0; i < n; i = i + 2)
pare[i] = v[i];
int maxi = maxim(pare, 0, n - 1);
cout << "maximul este" << ' ' << maxi;
4. Să se scrie un subprogram recursiv care calculează și returnează suma elementelor

vectorului care au ultima cifra 5, folosind metoda Divide et Impera, precum și
programul principal (funcția main) care demonstrează utilizarea acestui subprogram.
Transmiterea datelor se va realiza exclusiv prin parametri. Elementele vectorului
sunt indexate de la 0.

corectă.
Exemplu de test:Sa se execute programul pentru urmatoarele date de intrare:

a={4,8,15,2,35,9,5} cu n=7 elemente.
(suma=55)
Pb rezolvata in c:
#include <stdio.h>
void suma5(int n, int* v, int& s) {
if (n == 1) {
if (v[0] % 10 == 5)
s += v[0];
}
else {
if (n % 2 == 0) {
suma5(n / 2, v, s);
suma5(n / 2, v + n / 2, s);
else {
suma5(n / 2, v, s);
suma5(1 + n / 2, v + n / 2, s);
int main() {
int n = 7, a[] = { 4, 8, 15, 2, 35, 9, 5 };
int s = 0;
suma5(n, a, s);
printf("Suma este: %d", s);
return 0;
Pb 4 rezolvata in C++:
#include <iostream>
using namespace std;
void suma5(int n, int* v, int& s) {
if (n == 1) {
if (v[0] % 10 == 5)
s += v[0];
}
else {
if (n % 2 == 0) {
suma5(n / 2, v, s);
suma5(n / 2, v + n / 2, s);
else {
suma5(n / 2, v, s);
suma5(1 + n / 2, v + n / 2, s);
int main() {
int n = 7, a[] = { 4, 8, 15, 2, 35, 9, 5 };
int s = 0;
suma5(n, a, s);
cout << s;
return 0;
Pb 6
Scrieți un subprogram recursiv care determină maximul dintre valorile impare dintr-un
vector folosind metoda Divide et Impera, precum și programul principal (funcția main)
care demonstrează utilizarea acestui subprogram. Transmiterea datelor se va realiza
exclusiv prin parametri. Elementele vectorului sunt indexate de la 0.

corectă.
Exemplu de test: vectorul v={6,20,17,15,4} cu n=5 elemente (maximul impar e 17)

#include <stdio.h>
void max_impar(int v[20], int n, int* max)
if (n >= 0)
if (v[n] % 2 == 1 && v[n] > *max)
*max = v[n];
max_impar(v, n - 1, max);
int main()
int v[] = { 6,20,17,15,4 };
int max = v[4];
max_impar(v, 3, &max);
printf("Maximul impar din vector este..: %d", max);
return 0;
Pb 7.
Se dă o mulțime S cu n elemente reale ordonate crescător. Scrieti un subprogram care

determină o submulțime a lui S, astfel încât suma elementelor submulțimii să fie
minimă precum și programul principal (funcția main) care demonstrează utilizarea
acestui subprogram. Transmiterea datelor se va realiza exclusiv prin parametri.
Elementele vectorului sunt indexate de la 0.

corectă.
Exemplu de test: Pentru urmatoarele date de intrare S={-8,-5,-3,2,6,7} cu n=6
elemente. (Suma minima=-16)
#include <stdio.h>
void suma_minima(int v[20], int n, int* s)
int i = 0;
while (v[i] <= 0 && i <= n)
*s = *s + v[i++];
int main()
int v[] = { -8,-5,-3,2,6,7 };
int s = 0;
suma_minima(v, 5, &s);
printf("Suma minima din vector este..: %d", s);
return 0;
Alte pb:
1. Să se scrie să se apeleze în main e o funcție recursivă care calculează și

returnează diferența dintre suma numărului elementelor strict pozitive și suma
numărului elementelor negative dintr-un vector v cu n elemente. . Transmiterea
datelor se va realiza exclusiv prin parametri. Elementele vectorului sunt indexate de
la 0.

corectă.
Exemplu de test:Daca functia primeste vectorul v=(4,-4,1,-1,3,3,-6) cu n=7

#include <stdio.h>
int a[10], n;
int Suma(int n, int a[])
if (n == 0)
return 0;
else
if (a[n] > 0)
return(a[n] + Suma(n - 1, a));
else
return(-1 * a[n] + Suma(n - 1, a));
void main()
printf("Introduceti nr de elemente: ");
scanf_s("%d", &n);
for (int i = 1; i <= n; i++)
printf("Elementul [%d] = ", i);
printf("Suma = %d", Suma(n, a));
}
2. Să se scrie și să se apeleze în main o funcție recursivă care calculează și
returnează diferența dintre suma numărului elementelor pare și suma numărului
elementelor impare dintr-un vector v cu n elemente.
Transmiterea datelor se va realiza exclusiv prin parametri. Elementele vectorului

sunt indexate de la 0.

corectă.
Exemplu de test:Daca functia primeste vectorul v=(4,-4,1,-1,3,3,-6) cu n=7
#include <stdio.h>
int a[10], n;
int Suma(int n, int a[])
if (n == 0)
return 0;
else
if (a[n] % 2 == 0)
return(a[n] + Suma(n - 1, a));
else
return(-1 * a[n] + Suma(n - 1, a));
void main()
printf("Introduceti nr de elemente: ");
scanf_s("%d", &n);
for (int i = 1; i <= n; i++)
{
printf("Elementul [%d] = ", i);
printf("Suma = %d", Suma(n, a));
}
//djikstra
#include<stdio.h>
#include <malloc.h>
const float variabila = 1000;
int citire(int a[20][20], int* n, int* m)

{
int j, vf, vi, i, inf;
int cost;
FILE* f;
int er = 1;
char nume[20];
gets_s(nume);
if (f != NULL)
{
fscanf(f, "%d", &(*n));
fscanf(f, "%d", &(*m));
for (i = 0; i < *n; i++)
for (j = 0; j < *n; j++)
a[i][j] = 1000;
for (i = 0; i < *m; i++)
{
fscanf(f, "%d", &vi);
fscanf(f, "%d", &vf);
fscanf(f, "%d", &cost);
printf("\ncostul este %d\n", cost);
a[vi - 1][vf - 1] = a[vf - 1][vi - 1] = cost;
}
fclose(f);
}
else er = 0;
return er;
}

{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%7d ", a[i][j]);
printf("\n");
}
}
void dijkstra(int c[20][20], int n, int l[20], int pred[20], int x)
{
int s[30], k, r, i, m, g, x0;
x0 = x - 1;
for (i = 0; i < n; i++)
{
l[i] = c[x0][i];
s[i] = 0;
if (c[x0][i] != 1000)
pred[i] = x0;
else pred[i] = -1;
}
g = 0;
s[x0] = 1;
r = 1;
do
{
m = 1000;
for (i = 0; i < n; i++)
if ((s[i] == 0) && (l[i] < m))
{
m = l[i]; k = i;
}
r = r + 1;
if ((l[k] != 1000) && (r <= n - 1))
{
s[k] = 1;
for (i = 0; i < n; i++)
if ((s[i] == 0) && (l[i] > l[k] + c[i][k]))
{
l[i] = l[k] + c[i][k]; pred[i] = k;
}
}
else
g = 1;
} while (g != 1);
}
void main()
{
int a[20][20], n, m, l[20], i, j, pred[20], x,v,drum[30],k,nod;
citire(a, &n, &m);
afisare(a, n);
printf("\nvarful initial este: ");
scanf("%d", &x);
dijkstra(a, n, l, pred, x);
for (i = 0; i < n; i++)
if (i != x - 1)
printf("\ncostul minim de la varful %d la varful %d este %d", x, i + 1, l[i]);
for (i = 0; i < n; i++)
if (i != x - 1)
printf("\npredecesorul lui %d este %d", i + 1, pred[i] + 1);
printf("\nvarful final este: ");
scanf("%d", &v);
drum[0] = v;
k = 1;
i = v - 1;
while (i != x - 1)
{
drum[k] = pred[i] + 1;
k = k + 1;
i = pred[i];
}
printf("\ndrumul de la varful %d la varful %d este:", x, v);
for (i = k - 1; i >= 0; i--)
printf("%d ", drum[i]);
for (nod=0;nod<n;nod++)
{
if (nod != x-1)
{
drum[0] = nod+1;
k = 1;
i = nod;
while (i != x - 1)
{
drum[k] = pred[i] + 1;
k = k + 1;
i = pred[i];
}
printf("\ndrumul de la varful %d la varful %d este:", x, nod+1);
for (i = k - 1; i >= 0; i--)
printf("%d ", drum[i]);
}
}
}
Seminar 5
Lucrul cu fișiere text și fișiere binare – probleme economice
Probleme propuse:
1. Fie un fişier organizat secvențial, cu date referitoare la punctele obținute de studenți la disciplina Algoritmi și
tehnici de programare. Articolele au următoarea structură:
Nume şi Gru Puncte proba practică Puncte teme (0-1)
Nr. matricol Puncte examen (0-50)
prenume pa (0-30) 1 2 … 10
cha cha cha cha
int char[30] int char char
r r r r
Scrieți programul care înregistrează în fișier punctajul obținut de un student la examen. Studentul este identificat
prin numărul matricol. Programul trebuie să ofere posibilitatea repetării, pentru înregistrarea punctajelor mai
multor studenți.
Includeți în program un subprogram care generează, într-un fișier text, o listă cu toate datele din fișierul binar.
Lista trebuie să apară ca tabel, cu coloanele corect aliniate.
2. Fie un fişier organizat secvențial, cu date referitoare la punctele obținute de studenți la disciplina Algoritmi și
tehnici de programare. Articolele au următoarea structură:
Nume şi Gru Puncte proba practică Puncte teme (0-1)
Nr. matricol Puncte examen (0-50)
prenume pa (0-30) 1 2 … 10
cha cha cha cha
int char[30] int char char
r r r r
Scrieți programul care înregistrează înmatricularea unui nou student (punctajele vor avea valori nule).
3. Fie un fişier organizat relativ, cu date referitoare la absențele studenților de la cursuri și seminarii/laboratoare
pentru fiecare dintre cele 15 discipline specifice fiecărui an de studiu. Cheia relativă este numărul matricol al
studentului (domeniul de valori pentru numerele matricole începe de la 0). Articolele au următoarea structură:
A Absențe (0-14)
Nr. Nume şi Gru n
Indicator de stare (0/1)
matricol prenume pa (1- 1 2 … 15
5)
C S C S C S
ch c
char int char[25] int
ar h char char char char char
ar
Numărul de activități la fiecare disciplină este 14.
Scrieţi un program care înregistrează exmatricularea unui student. Studentul este identificat prin numărul
matricol.
4. Fie un fişier organizat relativ, cu date referitoare la absențele studenților de la cursuri și seminarii/laboratoare
pentru fiecare dintre cele 15 discipline specifice fiecărui an de studiu. Cheia relativă este numărul matricol al
studentului (domeniul de valori pentru numerele matricole începe de la 0). Articolele au următoarea structură:
Nr. Nume şi Gru A Absențe (0-14)
Indicator de stare (0/1)
matricol prenume pa n 1 2 … 15
1
(1-
C S C S C S
ch c
char int char[25] int
ar h char char char char char
ar
Numărul de activități la fiecare disciplină este 14.
Scrieţi un program care înregistrează o nouă absență a unui student la o activitate. Studentul este identificat prin
numărul matricol, activitatea este identificată prin poziția în vector (1-15) și tip (Curs/Seminar).
Exemple de rezolvare:
Observatii:
 Fisierul binar trebuie sa se regaseasca in directorul proiectului
 În Visual Studio versiuni mai noi extensia fișierului sursă trebuie să fie .c (nu .cpp) – (dacă aveți eroare
legată de funcția gets)
 #define _CRT_SECURE_NO_WARNINGS //în cazul în care apar avertismente legate de securitate
1. Problema 1
//Fisierul binar se numeste Puncte.dat
#include<stdio.h>
typedef struct{int nr;

char nume[30];
int grupa;
char pp;
char teme[10];
char examen;
}STUDENT;
void lista_studenti(FILE *f)

{
char nume[30];
STUDENT s;
FILE *g;
int n,i;
printf("\nFisier rezultat (text): ");gets(nume);
g=fopen(nume,"w");
fprintf(g,"\nNr. Nr. mat Nume %15s Grupa PP Punctaj teme Examen"," ");
fread(&s,sizeof(STUDENT),1,f);
n=0;
while(!feof(f))
{
fprintf(g,"\n%3d %8d %-30s %2d %2d ",++n,s.nr, s.nume,s.grupa, s.pp);
for(i=0;i<10;i++)
fprintf(g,"%2d ",s.teme[i]);
fprintf(g,"%6d ",s.examen);
2
}
fclose(g);
}
void main()
{FILE *f;
char nume[30];
STUDENT s;
int gasit,n,j;
printf("\nFisier: ");gets(nume);
f=fopen(nume,"rb+");
if(!f)printf("\nFisierul %s nu poate fi deschis", nume);
else
{
lista_studenti(f);
printf("\nNr. matricol: ");scanf("%d",&n);
while(!feof(stdin))
{rewind(f);
gasit=0;
while((!feof(f))&&(gasit==0))
{
if(n==s.nr)
{gasit=1;
printf("\nNr.mat:%3d Nume: %-30s Grupa: %4d Punctaj pp: %2d\n: ",s.nr,s.nume,s.grupa, s.pp);
for(j=0;j<10;j++)
printf("%2d ",s.teme[j]);
printf("Punctaj examen: %2d ",s.examen);
printf("Introduceti punctajul la examen:");
scanf ("%d", &s.examen);
fseek(f, ftell(f)-sizeof(STUDENT),0);
fwrite(&s, sizeof(STUDENT), 1, f);
}else
}
if(gasit==0)printf("\nNu a fost gasit.");
printf("\nNr. matricol: ");scanf("%d",&n);
}
fclose(f);}
}
3
Va fi creat fișierul text cu studenții din fișierul binar
2. Problema 2
//Fisierul binar se numeste Puncte.dat

#include<stdio.h>
typedef struct{int nr;

char nume[30];
int grupa;
char pp;
char teme[10];
char examen;
}STUDENT;

4
{
char nume[30];
STUDENT s;
FILE *g;
int n,i;
g=fopen(nume,"w");
fprintf(g,"\nNr. Nr. mat Nume %15s Grupa PP Punctaj teme Examen"," ");
n=0;
while(!feof(f))
{
fprintf(g,"\n%3d %8d %-30s %2d %2d ",++n,s.nr, s.nume,s.grupa, s.pp);
for(i=0;i<10;i++)
fprintf(g,"%2d ",s.teme[i]);
fprintf(g,"%6d ",s.examen);
}
fclose(g);
}
void main()
{FILE *f;
char nume[30];
STUDENT s;
int i;
else
{
lista_studenti(f);
fseek(f,0,2);//pozitionare la sfarsitul fisierului
printf("Nr.matricol: ");scanf("%d",&s.nr);
while(!feof(stdin))
{
printf("Nume: ");getchar(); gets(s.nume);
printf("Grupa: ");scanf("%d",&s.grupa);
s.pp=0;
for(i=0;i<10;i++)s.teme[i]=0;
s.examen=0;
fwrite(&s,sizeof(STUDENT),1,f);
printf("Nr.matricol: ");scanf("%d",&s.nr);
}
fclose(f);}
}
5
La urmatoarea listare in fișier text se poate observa că cei doi studenți au fost adaugați la sfârșitul fișierului
3. Problema 3
//Fisierul binar se numeste Absente.dat

#include<stdio.h>
typedef struct {char c,s;} DISCIPLINA;
typedef struct{
char is;
int nr;
char nume[25];
int grupa;
char an;
DISCIPLINA abs[15];
}STUDENT;

{
char nume[30];
STUDENT s;
FILE *g;
int n,i;
g=fopen(nume,"w");
fprintf(g,"\nNr. Nr. mat Nume Grupa An Absente curs si seminar ");
n=0;
while(!feof(f))
6
{
if(s.is==1)
{fprintf(g,"\n%3d %8d %-30s %6d %4d ",++n,s.nr, s.nume,s.grupa, s.an);
for(i=0;i<15;i++)
fprintf(g,"%2d,%2d ",s.abs[i].c,s.abs[i].s);
}
}
fclose(g);
}
int nrart(FILE *f, int l)

{long p; int n;
p=ftell(f);
fseek(f,0,2);
n=ftell(f)/l;
fseek(f,p,0);
return n;
}
void main()
{FILE *f;
char nume[30];
STUDENT s;
int n;
else
{
lista_studenti(f);
printf("\n Numarul matricol:"); scanf("%d",&n);
while(!feof(stdin))
{
if(n>=nrart(f,sizeof(STUDENT)))
printf("Studentul nu exista!");
else{
fseek(f,n*sizeof(STUDENT),0);
fread(&s,sizeof(STUDENT), 1, f);
if(s.is==0) printf("Studentul nu exista!");
else{
fseek(f,n*sizeof(STUDENT),0);
printf("Studentul %s va fi exmatriculat: ",s.nume);
s.is=0;
fwrite(&s,sizeof(STUDENT), 1, f);
}
}
7
printf("\nNumar matricol: "); scanf("%d",&n);
}
fclose(f);}
}
După încă o apelare se poate observa că în fișierul text rezultat nu mai apare studentul cu numarul matricol
respectiv
4. Problema 4 – tema
Obs. Este tot o modificare (ca si la problema anterioara), dar a altui câmp din structura articolului
Important: se va avea în vedere lucrul cu fișiere binare organizate secvențial și relativ (a se vedea toate operațiile
discutate la curs), precum și rapoarte în fișiere text

Probleme Atp

Uploaded by

Copyright:

Available Formats

Probleme Atp

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Probleme Atp

Uploaded by

Copyright:

Available Formats

//ARANJAMENTE

void afisare(int n, int st[])

int valid(int k, int st[])

void back(int n, int m, int st[], int* nrsol)

void afisare(int n, int st[])

int valid(int k, int st[])

void back(int n, int m, int st[], int* nrsol)

//GREEDY (iterativ) – solutia optima

for (i = 0; i < *n; i++)

void afisare(float v[][2], int n, int b[10]) {

void afisare(int n, int st[])

int valid(int k, int st[])

void back(int n, int st[], int* nrsol)

void Roy_Warshall(int a[20][20], int n, int m[20][20])

printf("\n componenta conexa=%d", ncc + 1);

printf("\nnumarul componentelor conexe=%d", ncc);

int citire(int** v, int* n)

void afisare(int v[], int n)

void interclasare(int v[], int li, int ls, int m)

void div_imp(int v[], int p, int u)

//TOATE SUBMULTIMILE UNEI MULTIMI

void afisare(int n, int st[])

void back(int n, int m, int st[], int* nrsol)

//BF PARINTE, DRUM, VF VIZITATE

if (!x || !y) //daca x=0 sau y=0

//CAUTA UN ELEMENT DIN VECTOR SI II SPUNE POZITIA

1. Problema celor n regine/dame

5. Problema colorarii hartilor

6. Plata unei sume cu/fara bancnota unitara

7. Problema misionarilor si a canibalilor

typedef struct Stare {

int solution(State st) {

int stateExisted(State st, State allStates[MAX], int n) {

int failure(State st, State allStates[MAX], int n) {

State move(State currentState, int to, int nrMissionaries, int nrCannibals) {

// generate all possible moves

char path[MAX] = "";

8. Problema cavalerilor mesei rotunde

//verificam daca valoarea lui i e acceptata

int posibil(int *v,int i, int n)

void retine_solutia(int num, int n, int *v)

//n-dimensiunea, i-pas curent, x-sol partiala curenta

int cavaleri(int n, int i, int *x, int nr)

int nr, v[100];

10) Generarea tuturor submultimilor unei multimi

char sp[] = " ";

int x[20], n, nrsol = 0;

int inserare_in_coada(int* coada, int n, int vf)

int extrage_nod_din_coada(int* coada, int n, int* vf)

void parcurgere_in_latime(int v0, int** a, int n)

2. Pracurgerea in adancime a grafurilor DF

void parcurgere_in_adancime(int v0, int** a, int n)

3. Parcurgeri generalizate DFG & BFG

5. Coversie reprezentare tabelara in reprezentare

int** conversie_matrice(int nr_vrf, int nr_muchii, int** tabel, int* dim)

6. Obtinere lista de adiacente

7. Roy-Warshall pentru matricea existentei

//introducere date de la tastatura

int conversie_matrice(int nr_vrf, int nr_muchii, int tabel, int* dim)

int Roy_Warshall(int a, int n)

int mw = (int)malloc(n sizeof(int*));

int Roy_Warshall(int a, int n)

int mw = (int)malloc(n sizeof(int*));

float mw = (float)malloc(n sizeof(float*));

prel = (int)malloc(n sizeof(int));