Reprezentare date Operatii

Rezolvare problema: toate de la reprezentare date in ordine

Generarea tuturor permutarilor

#include <stdio.h> int n, v[100]; int valid(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 == n) {return 1;} return 0;} void afisare(int k) { int i; for (i = 1; i <= k; i++)
{printf("%d ", v[i]);} printf("\n"); } void BK(int k) { int i; for (i = 1; i <= n; i++) {v[k] = i; if (valid(k)) { if
(solutie(k)) afisare(k); else BK(k + 1); } } } void main() { printf("Introduceti n: "); scanf_s("%d", &n); BK(1); }

Generarea tuturor aranjamentelor

#include <stdio.h> int n, v[100], p; int valid(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 == p) {return 1;} return 0; } void afisare(int k) { int i; for (i = 1; i <= k; i++)
printf("%d ", v[i]); printf("\n"); } void BK(int k) { int i; for (i = 1; i <= n; i++) { v[k] = i; if (valid(k)) { if
(solutie(k)) afisare(k); else BK(k + 1); } } } void main() { printf("Introduceti n: "); scanf_s("%d", &n);
printf("Introduceti p: "); scanf_s("%d", &p); BK(1); }

Generarea tuturor combinatilor

#include <studio.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("%d ", v[i]); printf("\n"); } void BK(int k) { int i; for (i = v[k - 1] + 1; i <= n;
i++) { v[k] = i; if (solutie(k)) afisare(k); else BK(k + 1); } } void main() { printf("Introduceti n: ");
scanf_s("%d", &n); printf("Introduceti p: "); scanf_s("%d", &p); BK(1); }

Problema colorarii hartilor

#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(); }
Problema celor 8 (n) regine

#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); }

Plata unei sume (cu / fara bacnote unitate)

#include<stdio.h> #define MAX 20 int n = 0, x, v[MAX], w[MAX], z[MAX], S, Suma, sol; 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 { fscanf_s(f, "%d", &S); fscanf_s(f, "%d", &n); for (i = 1; i <= n; i++) { fscanf_s(f, "%d", &w[i]); z[i] = S /
w[i]; } } } void main() { citire(); BK(1); }

Cavaleri mesei rotunde

#include<stdio.h> #include<math.h> #include<malloc.h> 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; } 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); } 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); }

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); }

Generarea tuturor submultimiilor dintr-o multime

#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"); nrsol++; } 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 "); printf(" Dati valoarea unui n:"); scanf("%d", &n); printf("\n");
BackRec(1); printf("Nr. solutii: %d\n", nrsol); _getch(); return 0; }
Parcuregre in latime

#define _CRT_SECURE_NO_WARNINGS #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); }

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)); for (i = 0; i < *nr_muchii; i++) 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> 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(3 * sizeof(int)); for (i = 0; i < *nr_muchii; i++) fscanf_s(f,"%d %d %d", & (*g)[i][0], & (*g)[i]
[1], &(*g)[i][2]); 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 ", tabel[i][0], tabel[i][1]);
printf("Ponderea muchiei este: %d\n", tabel[i][2]); } }

Coversie reprezentare tabelara in reprezentare matriceala

//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)); for (i = 0; i < *nr_muchii; i++) 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() { 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,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("%d ", a[i]
[j]); printf("\n"); } }

//graf ponderat

#include #include #define INF 1000 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(3 * sizeof(int)); for (i = 0; i < *nr_muchii; i++) 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() { 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,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("%d ", a[i][j]); printf("\n"); } }

Dijkstra cu preluare graf din fisier

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<>malloc.h #define INF 1000000

typedef struct { float l; int vf; }eticheta; 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)); fscanf(f, "%i", &m); for (i =
0; i < *n; i++) for (j = 0; j < *n; j++) mw[i][j] = INF; for (i = 0; i < m; i++) { fscanf(f, "%i", &u); fscanf(f, "%i",
&v); 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)); for (i = 0; i < n; i++) prel[i] = 0; prel[v0 - 1] = 1; ui = v0; for (nrit = 0; nrit < n -
1; nrit++) { lmin = INF; 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]; printf("Introduceti numele fisierului care contine
graful:"); 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); }

Verificare existenta varfuri izolate

#include<stdio.h> #include<conio.h> void citire(int a[][30], int* n, int* m) { FILE* f; int u, v, i; char
Numefis[40]; printf_s("numele fisierului: "); gets_s(Numefis); fopen_s(&f, Numefis, "r"); if (f == NULL)
printf_s("\n Nu se poate deschide!"); else { fscanf_s(f, "%d %d", n, m); 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; for (i = 0; i < n; i++) for (j = 1; j < n; j++) if (a[i][j] == 1) ok = 0; if (ok == 1) return 1; else return
0; } 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(); }

Verificare graf complet

#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!"); else { fscanf_s(f, "%d %d", n, m); for (i = 1; i <= *m; i++) { fscanf_s(f,
"%d", &x); fscanf_s(f, "%d", &y); 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(); }

Prim

//introducere graf de la tastatura, nu calculeaza bine

#define _CRT_SECURE_NO_WARNINGS #include #include #include 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;
printf("Numarul de virfuri:"); scanf("%i", &nv); printf("Numarul de muchii:"); scanf("%i", &nm); 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> #pragma warning (disable:4996) 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); fscanf(f, "%d", &m); 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", &x); fscanf(f, "%d", &y); 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(); }

Pracurgerea in adancime a grafurilor DF

#define _CRT_SECURE_NO_WARNINGS #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; 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); }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); }

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); printf("Introduceti numarul
de muchii:"); 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"); } int
conex = verificare_conexitate(m, n); if (conex == 1) printf("\nGraful este conex"); else printf("\nGraful nu
este conex");}

//citire graf din fisier text

#define _CRT_SECURE_NO_WARNINGS #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)); 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; } 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]; printf("Introduceti numele
fisierului care contine graful:"); scanf("%s", numef); preia_graf(numef, &a, &n); printf("Matricea
existentei drumurilor este:\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); }

Kruskal
//preluare graf din fisier
#define _CRT_SECURE_NO_WARNINGS #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);
fscanf(f, "%d", &m); for (i = 0; i < m; i++) {fscanf(f, "%d", &x); fscanf(f, "%d", &y); 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(); }