Universitatea Tehnică a Moldovei

Catedra Automatică și Tehnologii Informaționale

Disciplina Structuri de Date şi Algoritmi

Varianta 7

RAPORT
privind efectuarea lucrării de laborator nr. 7

Tema: Analiza complexităţii şi eficienţei algoritmilor ale

TEHNICII PROGRAMĂRII

A realizat student grupa TI-

A verificat Moțpan Serghei

Chisinău 2018
Cuprin

2
1. Scopul și obiectivele lucrării....................................................................................................3
2. Sarcina......................................................................................................................................4
3. Schema bloc.............................................................................................................................5
Concluzii..........................................................................................................................................6
Bibliografie......................................................................................................................................7
Anexa A...........................................................................................................................................8
Anexa B...........................................................................................................................................9

3
 1. Scopul și obiectivele lucrării

1) De studiat şi însuşit materialul teoretic pentru evidenţierea esenţialului evaluării

tehnicilor de programare în elaborarea modelelor eficiente a soluţiei problemelor:
esenţa metodelor (strategiilor tehnicilor de apreciere) şi specificul realizării;
2) Să se analizeze complexitatea asimptotică şi notaţiile ei ca să se definească tehnica
modelării timpului de execuţie prin analiza empirică şi scenariile programării eficiente
prin calculul timpului de execuţie pentru diverşi algoritmi cu argumentări şi modele de
structuri abstracte;

3) Să se preia varianta problemei din Ll6 SDA pentru analiza empirică a complexităţii
algoritmilor şi calculul timpului de execuţie, implementând funcţiile de timp C, şi
rularea programelor în limbajul C;

4) Să se elaboreze scenariile succinte de modificare, utilizând pointeri, subprograme şi

fişiere cu teste de verificare şi vizualizări şi explicaţii la principalele subprograme prin
analiza comparativă. Folosiţi ceasul de timp real al sistemului pentru a estima
performanţele algoritmului.

4
 2. Sarcina
De analizat timpul de execuție a algoritmului selectat în laboratorul 6, de explicat ce înseamnă cel
mai defavorabil caz, timp mediu de execuție, complexitate asimtotică, notațiile de asimtotice, care
sunt etapele analizei complexității.

5
 3. Schema bloc

Figura 1 Schema bloc pentru funcția main

Figura 2 Schema bloc pentru funcția print_grid

6
 Concluzia

Lucrarea dată a avut ca scop să ne învețe esenţialul prelucrării structurilor de date prin
diferite metode de programare, fiecare având specificul ei de utilizare. Spre exemplu:

Backtracking - este o metodă de parcurgere sistematică a spaţiului soluţiilor posibile al

unei probleme. Este o metodă generală de programare, şi poate fi adaptă pentru orice problemă
pentru care dorim să obţinem toate soluţiile posibile, sau să selectăm o soluţie optimă, din
mulţimea soluţiilor posibile. Backtracking este însă şi cea mai costisitoare metodă din punct de
vedere al timpului de execuţie.

Greedy – pare atât de simplă încât, la început, ne miră faptul că a fost evidențiată ca
tehnică. La o analiză mai atentă, vom observa că lucrurile nu stau chiar așa. Exemplele
prezentate în indicațiile metodice, ele nu au alt rol decât a evidenția caracteristicile tehnicii.
Specificul acestei metode constă în faptul că se construiește soluția optimă pas cu pas, la fiecare
pas selectat în soluție elementul care pare ”cel mai bun” la momentul respectiv, în speranța ca va
duce la soluția optimă globală.

Divide et Impera – Algoritmii de tip Divide  et Impera au buna comportare in timp ,daca
se indeplinesc urmatoarele conditii:

- dimensiunile subprogramelor(in care se imparte problema initiala )sunt

aproximativ egale("principiul balansarii");

- lipsesc fazele de combinare a solutiilor subproblemelor(cautare binara).

7
 Bibliografie

1. The GNU C Reference Manual. [Interactiv] https://www.gnu.org/software/gnu-c-

manual/gnu-c-manual.html.
2. The C Library Reference Guide. [Interactiv] https://www-
s.acm.illinois.edu/webmonkeys/book/c_guide/.

8
 Anexa A

Figura 2 Sudoku care va fi rezolvat

Figura 3 Compilarea programului -> Sudoku rezolvat

9
 Anexa B
#include <stdio.h>

#define N 9

#define UNASSIGNED 0

int is_exist_row(int grid[N][N], int row, int num){

for (int col = 0; col < 9; col++) {

if (grid[row][col] == num) {

return 1;

return 0;

int is_exist_col(int grid[N][N], int col, int num) {

for (int row = 0; row < 9; row++) {

if (grid[row][col] == num) {

return 1;

return 0;

int is_exist_box(int grid[N][N], int startRow, int startCol, int num) {

for (int row = 0; row < 3; row++) {

for (int col = 0; col < 3; col++) {

if (grid[row + startRow][col + startCol] == num) {

return 1;

} 

return 0;

10
int is_safe_num(int grid[N][N], int row, int col, int num) {

return !is_exist_row(grid, row, num) 

&& !is_exist_col(grid, col, num) 

&& !is_exist_box(grid, row - (row % 3), col - (col %3), num);

int find_unassigned(int grid[N][N], int *row, int *col) {

for (*row = 0; *row < N; (*row)++) {

for (*col = 0; *col < N; (*col)++) {

if (grid[*row][*col] == 0) {

return 1;

return 0;

int solve(int grid[N][N]) {

int row = 0;

int col = 0;

if (!find_unassigned(grid, &row, &col)){

return 1;

for (int num = 1; num <= N; num++ ) {

if (is_safe_num(grid, row, col, num)) {

grid[row][col] = num;

if (solve(grid)) {

return 1;

grid[row][col] = UNASSIGNED;

return 0;

11
void print_grid(int grid[N][N]) {

for (int row = 0; row < N; row++) {

for (int col = 0; col < N; col++) {

printf("%2d", grid[row][col]);

printf("\n");

int main() {

int grid[N][N] = {{3, 0, 6, 5, 0, 8, 4, 0, 0},

                  {5, 2, 0, 0, 0, 0, 0, 0, 0},

                  {0, 8, 7, 0, 0, 0, 0, 3, 1},

                  {0, 0, 3, 0, 1, 0, 0, 8, 0},

                  {9, 0, 0, 8, 6, 3, 0, 0, 5},

                  {0, 5, 0, 0, 9, 0, 6, 0, 0},

                  {1, 3, 0, 0, 0, 0, 2, 5, 0},

                  {0, 0, 0, 0, 0, 0, 0, 7, 4},

                  {0, 0, 5, 2, 0, 6, 3, 0, 0}};

if (solve(grid)) {

print_grid(grid);

} else {

printf("no solution");

return 0;

12