Curs Metode de Analiza A Algoritmilor

qwertyuiopasdfghjklzxcvbnmq Maina Turing
wertyuiopasdfghjklzxcvbnmq
Metode de analiz a
algoritmilor
Note de curs
Mihaela Colhon
Cuprins
Algoritmi i funcii calculabile .............................................................................5
Instructiuni ........................................................................................................ 5
Caracteristicile algoritmilor ............................................................................... 9
Corectitudinea algoritmilor .......................................................................... 11
Calculabilitate .................................................................................................. 15
Maina Turing ....................................................................................................17
Calcule realizate de Maina Turing ................................................................. 21

Clase de complexitate ..................................................................................... 24
Familii de limbaje ............................................................................................ 25
Maina Turing ca acceptor de limbaj .............................................................. 27
Exerciii ............................................................................................................ 29
Analiza complexitii algoritmilor nerecursivi ...................................................30
Timpul de execuie .......................................................................................... 31

Cazuri de analiz.............................................................................................. 32
Analiza algoritmilor nerecursivi....................................................................... 33
Etapele analizei algoritmilor ..............................................................................37
Ordinul de cretere ......................................................................................... 37

Exerciii ............................................................................................................ 39
Notaii asimptotice ............................................................................................43
Notaia O ......................................................................................................... 44
Notaia ......................................................................................................... 47
Notaia ......................................................................................................... 48
Analiza asimptotic a principalelor structuri de prelucrare ............................ 52
Exerciii ............................................................................................................ 55
2
Analiza complexitii algoritmilor recursivi .......................................................57
Metoda substituiei ......................................................................................... 58

Metoda substituiei nainte ............................................................................. 59
Metoda substituiei napoi .............................................................................. 60
Metoda Iteraiei .............................................................................................. 61
Arbori de recuren ......................................................................................... 63
Metoda Master ............................................................................................... 64
Tehnica reducerii ............................................................................................. 65
Aplicaie a tehnicii de reducere....................................................................... 68
Exerciii ............................................................................................................ 70
Algoritmi recursivi. Studiu de caz ......................................................................72
Problema Turnurilor din Hanoi ....................................................................... 72

NP-completitudine ............................................................................................76
Limbaje formale .............................................................................................. 77

Verificri n timp polinomial ............................................................................ 79
Determinism .................................................................................................... 80
Clase de complexitate P i NP ......................................................................... 83
Reducere polinomial ..................................................................................... 87
Problema satisfiabilitii (SAT) ........................................................................ 88
Varianta 2SAT ............................................................................................. 91
Bibliografie ........................................................................................................93
3
4
Algoritmi si funcii calculabile
Algoritmi i funcii calculabile

Un algoritm este descris de o secven finit de pai ntr-o ordine logic
specific astfel nct executarea lor produce o soluie corect pentru
problema precizat. Algoritmii pot fi descrii n orice limbaj pornind de
la limbajul natural pn la limbajele formale ca de exemplu limbajul de
asamblare al unui calculator specific.
Un limbaj al crui scop unic este acela de a descrie algoritmi se numete

limbaj algoritmic. Limbajele de programare sunt exemple de limbaje
algoritmice. Limbajele algoritmice se considera limbaje tipizate, n sensul
c datele sunt organizate n tipuri de date.
Un algoritm cuprinde:
Domeniul de date: o mulime numrabil de elemente asupra

crora opereaz algoritmul i care cuprinde i elementele de ieire
ale algoritmului (rezultatele)
Descrierea algoritmului: un set finit de instruciuni care
opereaz pe/cu elementele din domeniul de date.
Limbajul algoritmic are caracteristica de modularitate, modulele fiind

reprezentate de subprograme. Exist dou tipuri de subprograme:
proceduri i funcii.
Instructiuni
Sintaxa instruciunii de atribuire este:
<variabila> <expresie>
unde <variabila> este un nume de variabil iar <expresie> este o

secven de operaii care n urma evalurii va produce un rezultat care se
va memora n locaia de memorie desemnat de <variabila>.
Atribuirea este singura instruciune cu ajutorul creia se poate modifica
memoria.
Sintaxa instructiunii if
if <conditie> then
<bloc_instructiuni1>
else
<bloc_instructiuni2>
endif
unde <conditie> este o expresie care prin evaluare va produce un

rezultat boolean. Componenta else a intruciunii if este facultativ.
Sintaxa instructiunii while
while <conditie> do
<bloc_instructiuni>
endwhile
Aceast instruciune implic evaluarea componentei <conditie>.

Dac rezultatul evalurii este true atunci se vor executa instruciunile din
<bloc_instructiuni> dup care se continu evaluarea condiiei.
Dac rezultatul evalurii este false atunci execuia instructiunii while se
termin.
6
Dac condiia nu este niciodat fals, atunci ciclul WHILE intr ntr-o
bucl infinit. Dac condiia este de la bun inceput fals, atunci ciclul
WHILE nu se va executa niciodat.
Sintaxa instructiunii for
for <variabila> <expresie_inf> to <expresie_sup> do
<bloc_instructiuni>
endfor
sau
for <variabila> <expresie_sup> downto <expresie_inf> do
<bloc_instructiuni>
endfor
pentru care <variabila> este o variabil de tip ntreg iar

<expresie_inf> i <expresie_sup> sunt expresii care prin
evaluare produc numere intregi.
7
Blocul de instruciuni al unei instruciuni for se execut cel puin o dat

dac rezultatul evalurii <expresie_inf> este mai mic sau egal dect
evaluarea <expresie_sup>.
Sintaxa intructiunii repeat
repeat
<bloc_instructiuni>
until <conditie>
unde <conditie> este o expresie care prin evaluare produce un

rezultat boolean iar <bloc_instructiuni> se execut atta timp ct
rezultatul produs prin evaluarea condiiei este fals (dar execuia
operaiilor din <bloc_instructiuni> este asigurat cel putin o
dat).
8
Acest tip de instruciune asigur execuia cel putin o dat a instruciunilor

din <statement>. Dac condiia nu devine niciodat adevarat atunci
ciclul REPEAT intr ntr-o bucl infinit.
Caracteristicile algoritmilor
O problem rezolvabil algoritmic o definim ca pe o funcie p total
definit pe mulimea datelor de intrare (I) cu valori n mulimea datelor
de ieire (O).
p: I O
Se poate ca, pentru anumite date din mulimea de intrare, problema p s

nu aib sens. Numim mai departe mulimea datelor de intrare pentru care
problema p are sens ca domeniul de date al algoritmului care
implementeaza problema p.
Rezumnd, un algoritm trebuie s aib urmtoarele proprieti:
Generalitate: un algoritm nu rezolv doar o anumit problem, ci o

clas de probleme de acelai tip: x I p(x)
Finititudine: un algoritm este compus dintr-un numr finit de
instruciuni. Mai mult, setul de transformri care se aplic pe datele
intrrii x I pentru a obine un rezultat din mulimea O este de
asemenea finit
Unicitate: numrul de transformri i ordinea n care sunt aplicate
sunt bine determinate de regulile algoritmului. Altfel spus, pentru
aceleai date de intrare x I, transformrile aplicate i rezultatele
obinute sunt mereu aceleai
Un algoritm trebuie s fie general. Algoritmul trebuie s funcioneze

pentru toate instanele intrrilor pentru care a fost definit i nu doar
pentru anumite instane.
De exemplu, s considerm problema sortrii cresctoare a unui ir de

numere.
(2,1,4,3,5) (1,2,3,4,5)
9
input output
Vom considera mai departe o variant de sortare prin metoda bulelor. a

crui descriere este urmtoarea:
- compar primele dou numere i, dac nu sunt n ordinea dorit,

le interschimb
- la fel procedeaz pentru perechea format din al doilea i al treilea

numr
- ....
- algoritmul continu pn ajunge s compare penultimul element

cu ultimul element
Este aceast variant de sortare un algoritm general? Realizeaz sortarea

pentru orice vector de numere?
Un algoritm trebuie s fie finit. Un algoritm trebuie s se termine, adic

s se opreasc dup un numr finit de pai. S considerm urmtorul
exemplu:
Step1: x 1
Step2: x x + 2
Step3: if x=10 then STOP
10
else GO TO Step 2
endif
Funcioneaz acest algoritm? Ce rezultat va genera?
Un algoritm trebuie s fie neambiguu. Operaiile unui algoritm trebuie

sa fie ntr-un mod riguros specificate. La fiecare pas al execuiei trebuie
s se tie precis care e pasul urmtor. S considerm urmtorul exemplu:
Step 1: x 0
Step 2: Either increment or decrement x with 1
Step 3: if x [-2,2] then GO TO Step 2
else Stop.
endif
Asupra unui algoritm se pun o serie de condiii:
Corectitudinea algoritmului
Condiia de oprire
Durata execuiei
Determinarea spaiului de memorie alocat
Corectitudinea algoritmilor
Atunci cnd proiectm un algoritm acesta trebuie s fie evaluat cel puin
din urmtoarele puncte de vedere:
Corectitudine: acest lucru nseamn s se verifice dac algoritmul

produce soluia corect (aceast rezultat trebuie de asemenea s fie obinut
dup un numr finit de prelucrri).
Eficien: acest lucru nseamn a stabili cantitatea de resurse (spaiu de

memorie i timp de execuie) necesare pentru a executa algoritmul pe o
main.
11
Testarea corectitudinii unui algoritm implic de obicei urmtorii pai:
1) Analiza experimental. Algoritmul se testeaz pe diferite instane ale

problemei. Principalul avantaj al acestei abordri este simplitatea ei, n
timp ce principalul dezavantaj este faptul ca testarea nu poate acoperi
ntotdeauna toate cazurile posibile ale datelor de intrare. Totui analiza
experimental permite uneori identificarea situaiilor n care algoritmul
nu funcioneaz.
2) Analiza formal. Scopul analizei formale este de a dovedi c

algoritmul funcioneaz pentru orice instan a datelor de intrare. Aceast
abordare este numit formal ca urmare a utilizrii regulilor formale de
logic cu scopul de a demonstra faptul c algoritmul respect
specificaiile sale. Principalul avantaj al acestei abordri este c, dac este
aplicat riguros, aceast analiz garanteaz corectitudinea algoritmului.
Principalul dezavantaj este dificultatea de a gsi o dovad, n special

pentru algoritmii dificili. n acest caz, algoritmul este descompus n
subprograme i analiza se concentrez pe aceste subcomponente. Pe de
alt parte, abordarea formala ar putea duce la o mai bun nelegere a
algoritmilor.
Principalele etape n analiza formal a corectitudinii unui algoritm sunt:
Identificarea proprietilor de date de intrare (aa numita problem a

precondiiilor).
Identificarea proprietilor pe care trebuie s le ndeplineasc datele de

ieire (aa numita problem a post-condiiilor).
Demonstrarea faptului c, ncepnd de la precondiii i prin executarea

aciunilor prevzute n algoritm se obin postconditiile.
Cnd analizm corectitudinea unui algoritm un concept util este cel al

strii algoritmului.
Starea algoritmului este definit prin setul de valori corespunztor

pentru toate variabilele utilizate n algoritm.
12
n timpul executiei, un algoritm trece prin mai multe stri (de obicei prin
atribuiri de valori variabilelor) de la un pas la alt pas de prelucrare. Ideea
de baz a verificrii corectitudinii este aceea de a stabili care trebuie s
fie starea corespunztoare fiecrei etape de prelucrare astfel nct, la
sfritul algoritmului postcondiiile s fie ndeplinite. Odat ce am stabilit
aceste stri intermediare este suficient s verificm dac fiecare pas de
prelucrare asigur transformarea corecta a starii actuale n starea
urmtoare.
n cazul n care structura de prelucrare este una secvenial atunci

procesul de verificare este imediat (trebuie s analizm doar efectul pe
care atribuirile l determin asupra strii algoritmului).
Dificultile pot aprea datorit instruciunilor repetitive, deoarece exist

multe surse de erori: iniializrile poate fi greite, etapele de prelucrare
din interiorul buclei pot fi greite sau condiia de oprire poate fi greit. O
metod formal de a dovedi c o instruciune repetitiv funcioneaz
corect este prin metoda induciei matematice.
Exemplu. Algoritmul de sortare prin inserie:
Input: un vector de n elemente v[1...n].
Output: un vector obinut prin sortarea elementelor din v.
Descrierea formal a algoritmului: se pornete cu o list vid de elemente

i succesiv, se insereaz elementele din v n poziia corect conform
ordinii de sortare.
Algoritmul de sortare prin insertie
for j 2 to n do
key v[j]
i j-1
while (i > 0 and v[i] > key)
v[i+1] v[i]
i i-1
endwhile
13
v[i+1] key
endfor
S demonstrm corectitudinea algoritmului de sortare prin insertie prin

metoda induciei matematice. Scopul este de a demonstra c o
instruciune I(n) este adevrat pentru toate numere naturale, ncepnd cu
n = 1.
Folosind inducia matematic, doi pai sunt suficienti pentru acest scop:
1. Cazul de baz. Se arat c I(1) este adevrat.
2. Pasul inductiv. S presupunem c I(k) este adevrat pentru k < n. Se

demonstreaz c I(k + 1) este de asemenea adevrat.
Invariani n structurile repetitive (n englez Loop invariants) sunt

instruciuni care sunt valide n orice moment al execuiei buclei. Relativ
la invariani trebuie s considerm trei aspecte:
- Iniializare invariantul este adevrat nainte de prima iteraie
- ntreinere - dac invariantul este adevrat nainte de o iteraie,

rmne adevrat i nainte de urmtoarea iteraie
- Terminare - atunci cnd bucla se termin invariantul d proprietatea

util relativ la corectitudinea algoritmului
Pasul 0: se caut I - invariantul algoritmului de inserare.
La nceputul fiecrei iteraie a buclei for subvectorul v[1..j-1]

const din elementele vectorului initial v[1..j-1], dar n ordine
sortat.
Pasul 1: Cazul de baz, pentru j = 2, subvectorul v[1..j-1], const

dintr-un singur element i evident v[1...j-1] este sortat.
Pasul 2: Pasul inductiv
14
Pasul 3: Pasul de terminare al ciclului for. Algoritmul se termin atunci

cnd j depete valoarea lui n, i anume j=n+1. Deci, n baza
invariantului I, v[1..j-1] = v[1..n] ceea ce nseamn c n acest
moment vectorul este sortat.
Calculabilitate
Conceptele de funcie calculabil i algoritm formeaz conceptele de
baz din teoria calculabilitii fiind preluate din informatic i
matematic. Din punct de vedere tehnic, algoritmul este definit ca o
secven finit de pai neambigui i executabili a cror execuie asigur
rezolvarea taskului pentru care algoritmul n cauz a fost definit.
Teoria mulimilor constituie un instrument de descriere simpl i precis

a conceptului de funcie. Construirea unui model matematic pentru acest
concept este o sarcin relativ simpl deoarcere avem de a face cu un
proces static spre deosebire de algoritmi care sunt procese dinamice.
Calculabilitatea unei funcii nseamn existena unei maini de calcul i

implicit a unui program, care prin execuie pe maina aleas s calculeze
valorile funciei n orice punct din domeniul de valori al acesteia.
Definiie. O funcie f: I O este efectiv calculabil dac exist o

procedur efectiv de calculare a valorilor funciei pentru orice element x
I. O procedur efectiv este o mulime finit de instruciuni a cror
execuie se termin ntr-un timp finit i care implic o cantitate finit de
date pentru a obine un rezultat, mereu acelai pentru date identice.
n general un program scris ntr-un limbaj de programare este asimilat

conceptului de algoritm ceea ce nseamn c programul respectiv va
evalua o funcie. Dac domeniul de valori al funciei reprezint domeniul
datelor de intrare ale programului atunci valorile funciei vor fi
rezultatele programului.
Un algoritm constituie o reprezentare finit a unei metode (procedeu) de

calcul care permite rezolvarea unei probleme. El poate fi interpretat ca un
text de lungime finit, scris ntr-un limbaj artificial n care fiecare rnd
15
are o anumit semnificaie. Algoritmul descrie operaiile care se pot

efectua conform procedeului de calcul.
O problem rezolvabil algoritmic o gndim ca pe o funcie p total

definit pe mulimea datelor de intrare I (cel mult numrabil) cu valori
n mulimea datelor de ieire O (cel mult numrabil). Fiecare element x
I reprezint o instana a problemei (un caz particular) iar dac exist y
astfel nct f(x) = y atunci y este soluia problemei p pentru instana x. n
caz contrar se spune c p nu are soluie pentru instana x.
Dac exist un algoritm care rezolv o problem p acest lucru nu atrage

cu necesitate unicitatea acestuia. De asemenea un acelai algoritm se
poate comporta diferit pe seturi de date de intrare diferite.
16
Maina Turing
Maina Turing
O main Turing este un acceptor care poate s scrie pe banda de intrare.
n acest mod, banda de intrare devine o memorie auxiliar. Cnd a
inventat maina care i poart numele, Turing nu era interesat de
calculatoare ci de posibilitatea specificrii i rezolvrii problemelor de
matematic folosind mijloace automate. Adic, poate fi rezolvat orice
problem de matematic utiliznd nite reguli elementare de prelucrare a
irurilor?
1
Figure 1 Modele, paradigme i limbaje
Maina Turing este un dispozitiv algoritmic de tip simplu dar cu o putere

de calcul complex, capabil sa execute cei mai compleci algoritmi.
Orice alt model de calcul propus de-a lungul timpului, n final s-a dovedit
a fi mai puin expresiv, sau tot att de expresiv ct maina Turing. n
abordarea din care face parte acest dispozitiv de calcul, orice cantitate de
informaie folosit de un algoritm la intrare, la ieire sau ca valoare
intermediar este socotit ca un ir de simboluri.
1
Mihnea Muraru, Paradigme de Programare note de curs 2012
Maina Turing
n construcia teoretic a mainii, Turing a pornit de la modelul mainii

de scris:
- maina de scris este considerat drept un dispozitiv cu memorie

infinit (numr nelimitat de foi de scris)
- se poate mica nainte i napoi de la o poziie la alta
- poate s scrie un caracter n fiecare poziie
Turing a mbuntit acest model, nzestrnd maina Turing cu alte

faciliti cum ar fi:
- tergerea unui simbol din memorie (prin rescrierea lui cu un

caracter special caracterul blank)
- citirea simbolurilor de pe banda
- posibilitatea de a avea un numr foarte mare (chiar dac acesta
este finit) de configuraii interne
Maina Turing este compus din urmtoarele elemente:
- o band infinit de celule (de obicei finit la stnga i infinit la

dreapta). n fiecare celul se poate memora un caracter din
alfabetul de citire/scriere al mainii
- un cap de citire/scriere care se poate mica de la dreapta la stnga
deasupra benzii
- o unitate de control definit de un numr finit de reguli care
indic mainii ce s fac la fiecare micare a capului de
citire/scriere n funcie de starea curent i de simbolul citit
Figura 1 Arhitectura unei maini Turing
18
Maina Turing
Unitatea de control asigur execuia micrilor. O micare este format

din:
- stabilirea strii urmtoare pentru unitatea de control

- scrierea unui simbol pe banda de intrare i/sau micarea capului
de citire/scriere la stnga sau la dreapta
Definiie. O main Turing determinist este un tuplu de forma:
(S, , , s0)
unde:
- S este o mulime finit i reprezint mulimea strilor interne ale

mainii.
- este o mulime finit, alfabetul de intrare care conine simbolul
(caracterul blank) dar nu conine simbolurile L i R
- este funcia de tranziie definit astfel: : S (S
{STOP}) {L, R}
- s0 este starea iniial a mainii Turing
Dac s S, a i (s, a) = (p, b) nseamn c fiind n starea s i avnd

simbolul a sub capul de citire/scriere maina trece n starea p. Dac b
atunci simbolul a va fi nlocuit cu simbolul b, altfel capul de citire/scriere
se va deplasa la stnga sau la dreapta n funcie de valoarea simbolului b
{L, R}. Caracteristica de calcul determinist a acestei maini provine de
la faptul c dintr-o stare intern oarecare i primind un simbol pe banda
de intrare automatul va trece ntr-o stare unic determinat.
Un calcul determinist pentru o main Turing i pentru o intrare *

este o secven (posibil infinit) de stri pornind de la starea iniial a
mainii Turing astfel nct fiecare din aceste stri implic n mod unic
urmtoarea stare din secven.
Spunem c un calcul este nedeterminist dac dintr-o stare intern

oarecare, primind un simbol al alfabetului de intrare, maina poate trece
n nici o stare, ntr-o singur stare sau n mai multe stri. Trecerea dintr-o
stare intern n alta nu este asociat cu probabiliti.
19
Maina Turing
ncetarea funcionrii mainii Turing se face n momentul atingerii strii

STOP sau atunci cnd se ncearc mutarea capului de citire/scriere la
stnga dincolo de marginea din stnga a benzii de intrare.
Generaliznd conceptul de main Turing cu o singura band se obine

urmtorul model.
Definiie. O k-band main Turing determinist (k 1) este un sistem:
(S, , , s0)
unde:
- S este o mulime finit numit mulimea strilor

- este o mulime finit numit alfabetul mainii Turing
- : S K (S {STOP}) k {L, R}k
- s0 este starea iniial a mainii Turing
Se poate demostra c, din punct de vedere al puterii de calcul, o main

Turing cu k-benzi, k >1, este echivalent cu o main Turing cu o singur
band.
O maina Turing poate fi asimilat unui calculator care ruleaz un singur

program. Software-ul este reprezentat de funcia de tranziie iar
hardware-ul de banda de citire/scriere i de capul de citire/scriere. O
main Turing calculeaz o funcie, fixat, pe cuvintele de intrare. n
acest fel se comport ca un calculator avnd un program fixat. Singura
problem este c maina Turing n proiectarea clasic nu poate produce
ieiri, acestea trebuind s fie codificate tot prin strile interne ale mainii.
Observaie. O maina Turing este un acceptor determinist, ceea ce

nseamn c () s S i () a , dac exist i este definit funcia
pentru perechea (s, a) atunci (s, a) va trece ntr-o stare unic determinat.
O main Turing nedeterminist are aceleai componente ca una

determininst, cu excepia funciei de tranziie care se definete astfel:
: S Pf (S {L, R})
20
Maina Turing
Aceast definire a funciei de tranziie permite ca pentru o stare dat i un

simbol citit pe band, s avem un numr finit de posibiliti de a alege
configuraia n care trece maina.
Calcule realizate de Maina Turing

Definim configuraie a unei maini Turing un tuplu de forma (s, L, a,
R) n care s este starea curent a mainii, L este stringul de caractere
aflat la stanga capului de citire/scriere, a este simbolul aflat sub capul de
citire/scriere iar R este stringul aflat la dreapta capului de citire/scriere.
Un calcul realizat de o maina Turing este o secven finit de
configuraii de forma c0 |- c1 |- ... |- cn pentru care relaia |- este definit
astfel:
- (s, L, a, R) |- (p, L, b, R) dac i numai dac (s, a) = (p, b)

iar b .
- dac (s, a) = (p, b) iar b :
o (s, 1...k-1, k, k+1... n) |- (p, 1... k, k+1, k+2... n)
dac i numai dac (s, a) = (p, R).
o (s, 1...k-1, k, k+1... n) |- (s, 1...k-2, k-1, k... n)
dac i numai dac (s, a) = (p, L).
Se poate considera c o maina Turing tie s evalueze funcii definite pe

iruri de simboluri cu valori n iruri de simboluri. Dac mulimile 1 i
2 sunt dou mulimi alfabet care nu conin simbolul , s considerm
funcia f: 1* 2*. Spunem c maina Turing (S, , , s0) calculeaz
funcia f dac 1, 2 i pentru orice ir 1* dac () u 2*, f()
= u atunci avem
(s0, ) |-* (STOP, u).
Definiie. Pentru orice funcie f pentru care exist o maina Turing care o
calculeaz spunem c funcia f este Turing calculabil.
21
Maina Turing
S considerm reprezentarea unar a numerelor naturale. Peste alfabetul

= {1} reprezentarea unui numr natural n este
1 1. Evident, numrul 0

va fi reprezentat de stringul vid. n acest caz, o funcie f: N N este

calculabil de o main Turing dac aceasta calculeaza funcia f : *
*, f () = u, unde pentru n N, =
1 1 i u =
11.

Exemplu: S considerm funcia succesor f: N N, f(n) = n+1. S se

stabileasc dac aceast funcie este Turing calculabil.
Pentru a demonstra acest lucru, vom considera maina Turing ({s0}, {1},
, s0) cu urmtoarea funcie de tranziie:
1
s0 (STOP, R) (s0, 1)
Intr-adevr, pentru intrarea 11 vom avea (s0, 11) |- (s0, 111) |- (STOP,
111). Mai mult, pentru orice n 0, (s0, 1
1 ) |- (s0, 1 1 ) |-

(STOP,
1 1 ).

S ne mai amintim c elementele procesate de mainile Turing sunt

limbaje, adic mulimi de cuvinte. O main Turing primete la intrare un
cuvnt dintr-un anumit limbaj i produce la ieire un cuvnt dintr-un alt
limbaj, care este rspunsul ateptat. Dac rspunsurile sunt doar yes sau
no (adic un singur bit), atunci vom spune c maina Turing decide
limbajul format din toate cuvintele pentru care rspunsul este yes.
O main Turing poate fi utilizat i ca acceptor de limbaj. S considerm

un alfabet i un limbaj L peste acest alfabet, L . Definim funcia:
eval :* {yes, no}
astfel: oricare ar fi *
,
=
,
22
Maina Turing
Spunem c limbajul L este decidabil n sens Turing dac i numai dac

funcia eval este Turing calculabil.
Exemplu: S considerm limbajul L ca fiind limbajul cuvintelor de

lungime par peste alfabetul = {a}, i anume:
L = { *| = 1... n, n mod 2 = 0 }
Pentru a verifica dac limbajul L este Turing acceptabil, vom considera

maina Turing ({s0, ..., s6}, {a, } {D, N}, , s0) unde:
a D N
s0 (s1,L)
s1 (s2, ) (s4, R)
s2 (s3, L)
s3 (s0, ) (s6, R)
s4 (s5, D)
s5 (STOP, R) (STOP, R)
rspunde yes rspunde no
s6 (s5, N)
Verificarea decidabilitii limbajului L n raport cu maina considerat o

lasm ca exerciiu.
Observaie. La mainile Turing, noiunea de acceptare este mai larg

dect noiunea de decidabilitate. ntr-adevar, pentru un limbaj L peste
alfabetul spunem ca este Turing acceptabil dac exist o maina Turing
care se oprete dac i numai dac L, pentru orice *.
Ca o consecin direct, obinem c limbajele Turing decidabile sunt i

limbaje Turing acceptabile. Reciproca ns nu este valabil.
Exista probleme care nu pot fi rezolvate deloc de masina Turing numite

probleme nedecidabile.
23
Maina Turing
Clase de complexitate
Teoria complexitii calculului se refer la problemele de decidabilitate
prin prisma dificultii soluiei. Dificultatea unei probleme este descris
n termeni de resurse computaionale necesare celui mai eficient algoritm
care rezolv problema respectiv.
Vom descrie, pe scurt, clasele de complexitate cele mai importante.

Pentru fiecare din aceste clase se cunosc probleme complete (o
problem de decizie p se numete complet pentru o mulime S de
probleme de decizie dac p este element al mulimii S i orice problem
din S poate fi redus la p). Vom prezenta clasele de complexitate n
ordinea cresctoare a complexitii lor.
Spaiu constant Prima clas de complexitate este cea a mainilor care

folosesc o cantitate fix de spaiu pentru a-i face calculele. Aceast
cantitate este independent de mrimea datelor de intrare. Chiar i atunci
cnd datele de intrare tind la infinit, maina folosete la fel de puin
spaiu. Mainile Turing care nu folosesc nici un fel de spaiu pe band n
afara cuvntului citit pe banda de intrare se numesc automate finite.
Toate limbajele care se pot decide n spaiu constant se numesc limbaje
regulate. Aceste limbaje sunt extrem de importante n practic; exist
multe programare care manipuleaz limbaje regulate, de exemplu
interpretorul Perl.
Limbajele regulate sunt utile prin faptul c permit s se demonstreaze

faptul c ele pot fi acceptate n timp liniar: pentru orice limbaj regulat
exist o main Turing care decide un cuvnt de lungime n n timp O(n)
adic n timp ce l citete.
Spaiu logaritmic O alt clas de complexitate este cea a limbajelor care

pot fi acceptate folosind spaiu logaritmic n lungimea cuvntului de
intrare. Pentru orice cuvnt de lungime n maina nu folosete mai mult de
O(log n) celule de memorie pentru a procesa cuvntul.
Timp polinomial Cea mai folosit clas de complexitate este cea a

timpului polinomial, notat cu P. Putem defini matematic foarte precis
24
Maina Turing
timpul polinomial ca aparinnd problemelor care se pot decide n timp

f(n), unde f este un polinom. Se arat imediat c orice se poate calcula n
spaiu logaritmic, nu are niciodat nevoie de mai mult dect timp
polinomial.
Timp exponenial Problemele care au un astfel de timp de calcul

formeaz aa zisa clasa problemelor monstruase.
Familii de limbaje
Se numete alfabet sau vocabular V orice mulime finit i nevid de
simboluri (sau litere, caractere, variabile). Un cuvnt peste un alfabet V
este o secven p = a1a2 . . . an, ai V, i = 1, ... , n. Numrul n se numete
lungimea cuvntului i va fi notat cu |p|. Vom considera i cuvntul vid
care nu conine nici un simbol; evident || = 0.
Noiunea de cuvnt este fundamental n teoria limbajelor formale sau n

alte domenii ale informaticii; termeni sinonimi utilizai n literatur sunt
propoziie, fraz sau ir. S observm c nu exist o similitudine foarte
bun ntre noiunile de alfabet, cuvnt etc. din teoria limbajelor
formale i noiunile corespunztoare din lingvistic.
Mulimea tuturor cuvintelor peste un alfabet V o notm cu V+. Aceast

mulime mpreun cu cuvntul vid va fi notat cu V*.
Un limbaj L peste alfabetul V este o parte a mulimii tuturor cuvintelor

peste V , deci L V*.
Un limbaj peste un alfabet poate s fie o mulime finit sau infinit de

cuvinte. n cazul unei mulimi finite, el poate fi descris prin enumerarea
efectiv a cuvintelor limbajului. n cazul n care este o mulime infinit,
el poate fi definit punnd n evident structura cuvintelor lui.
Exist dou mecanisme de baz pentru definirea limbajelor:
1. Mecanisme generative, care permit generarea tuturor cuvintelor

limbajului. Exist mai multe tipuri de mecanisme de generare a
25
Maina Turing
limbajelor, ntre care gramaticile Chomsky, sistemele

Lindenmayer,etc.
2. Mecanisme analitice, care determin dac un cuvnt dat aparine sau
nu limbajului. Sunt aa-numitele automate, automate finite, automate
push-down.
Un rol deosebit n teoria limbajelor formale l au gramaticile Chomsky.

Fie VN i VT dou alfabete disjuncte, numite respectiv alfabetul
Notm alfabetul gramaticii cu V, evident V = VN VT i fie P

simbolurilor neterminale (VN) i alfabetul simbolurilor terminale (VT).
V*VNV* V*. Mulimea P va fi deci format din perechi de forma (u, v),
cu proprietatea c u = u1Au2, cu u1, u2 V*, A VN i v V*, deci u i v
sunt cuvinte peste V cu observaia c u trebuie s conin cel puin un
simbol neterminal. Vom spune c o astfel de pereche este o regul de
producie (regul de generare, regul de rescriere) i o vom nota u v
nota n mod urmtor: (u v) P.

(vom spune c u se transform n v). Apartenena unei reguli la P o vom
O gramatic (Chomsky) G este un sistem G = (VN , VT , S, P), unde VN
terminale, S VN este simbolul iniial al gramaticii, iar P este mulimea

este alfabetul simbolurilor neterminale, VT este alfabetul simbolurilor
de reguli.
Limbajul generat de gramatica G se definete ca mulimea cuvintelor w

peste alfabetul V:
! = "# $% |( #}
Tipuri de gramatici. Dup forma regulilor de generare, gramaticile

Chomsky se mpart n mai multe tipuri:
Gramatici de tipul 0 sunt gramatici fr restricii asupra regulilor;

Gramatici de tipul 1 (dependente de context); sunt gramatici care au
reguli de forma
uAv upv, u,p,v V* i A VN
sau A
26
Maina Turing
Gramaticile de tipul 2 (independente de context); sunt gramatici

care au reguli de forma:
A u, A VN i u V*
Gramaticile de tipul 3 (regulate); sunt gramatici care au reguli de
* ,- * -,
forma

./ ./
cu A, B, C VN i p, q VT*.
n raport cu aceast clasificare, n funcie de tipul de gramatic folosit la

generarea limbajului avem limbaje de ordin 0 (L0), 1 (L1), 2 (L2) sau 3
(L3).
Maina Turing ca acceptor de limbaj
n aceast seciune mainile Turing sunt descutate din punctul de vedere

al calitii lor de acceptoare de limbaje formale.
Maina Turing este un mecanism de recunoatere a limbajelor de tipul

zero. n felul acesta, familiilor de limbaje din clasificarea Chomsky le
corespund automate specifice de recunoatere:
- Familia L3 - automate finite,

- Familia L2 - automate pushdown,
- Familia L1 - automate liniar mrginite,
- Familia L0 - maina Turing
Limbajul recunoscut de o main Turing MT = (S, , , s0) se definete

ca mulimea:
L(MT) = { * | (s0, ) |-+ (STOP, ) }
Este posibil ca maina s ajung ntr-o stare final nainte de citirea

integral a cuvntului ns pentru a putea fi considerat acceptat,
27
Maina Turing
atingerea strii finale trebuie fcut numai dup parcurgerea cuvntului

.
Limbajul acceptat de o maina Turing este mulimea cuvintelor *

care, prin plasarea pe banda de intrare n partea stng a benzii determin
ca maina Turing, prin tranziiile efectuate i pornind din starea iniial
cu unitatea de comand/control poziionat pe prima locaie s ajung n
starea final avnd capul de citire/scriere pe ultima locaie a cuvntului
dat.
Deoarece clasa tuturor limbajelor peste un alfabet este 2 - mulime

nenumrabil, cum mulimea mainilor Turing este numrabil se pune

problema identificrii att a limbajelor acceptate dar i a limbajelor
neacceptate.
Un limbaj L este rezolvabil (decidabil) dac exist o main Turing MT

acceptor astfel nct pentru orice * calculul determinist al mainii se
oprete i accept intrarea dac i numai dac L (invers, pentru
L calculul determinist se oprete ntr-o stare de rejectare).
28
Maina Turing
Exerciii
1) S considerm urmtorul exemplu de main Turing: ({s0, s1}, {a,
}, , s0) pentru care funcia de tranziie este definit astfel:
a
s0 (s1, ) (STOP, )
s1 (s0, a) (s0, R)
S se stabileasc tranziiile pentru intrarea aaa pentru cazul n

care poziia capului este pe primul caracter din ir.
Rspuns: (s0, aaa) |- (s1, aa ) |- (s0, aa) |- (s1, a) |- (s0,

a) |- (s1, ) |- (s0, ) |- (STOP, )
2) S considerm urmtorul exemplu de main Turing: ({s0}, {a,
}, , s0) pentru care funcia de tranziie este definit astfel:
a
s0 (s0, L) (STOP, )

care poziia capului este pe ultimul caracter din ir.
3) S considerm urmtorul exemplu de main Turing: ({s0, s1, s2},
{a, b, }, , s0) pentru care funcia de tranziie este definit astfel:
a b
s0 (s1, L) (s1, L) (s1, L)
s1 (s0, b) (s0, a) (s2, R)
s2 (s2, R) (s2, R) (STOP, )

care poziia capului este pe ultimul caracter din ir. De asemenea,
s se determine comportamentul mainii pentru intrarea .
Hint. Funcia calculat de aceast main este funcia care
interschimb caracterele a i b.
29
Analiza complexitii algoritmilor nerecursivi
Analiza complexitii
algoritmilor nerecursivi
Analiza complexitii unui algoritm are ca scop estimarea volumului
resurselor de calcul necesare pentru execuia algoritmului:
Complexitate static: spaiul de memorie necesar pentru stocarea

datelor care se prelucreaz
Complexitate dinamic: timpul necesar pentru execuia tuturor
prelucrrilor specificate de instruciunile algoritmului
Dac n anii 1990 spaiul de memorie utilizat de un program era o resurs

critic datorit capacitii reduse a memoriilor calculatoarelor din acea
vreme, astzi aceast factor este mai puin important. Calculatoarele
actuale au suficient memorie pentru procesrile obinuite.
Bineneles ca volumul resurselor necesare depinde de volumul datelor de

intrare. Mai precis, dimensiunea datelor de intrare este calculat dup
numrul de bii necesari pentru stocarea datelor. Mrimea unei instane,
notat cu |x| este dat de numrul de bii necesari pentru stocarea lui x.
Astfel, cnd vorbim de stocare, |x| este numrul de elemente care se
sorteaz. La algoritmii numerici, |x| este valoarea numeric a instanei x.
Dintre cele dou resurse de calcul, cea critic este timpul de execuie.
Acesta depinde de numrul de operaii care trebuie efectuate i de
dimensiunea datelor de intrare. Deci, timpul de execuie difer de la
execuie la alta.
Avnd in vedere c pentru seturi de date de intrare diferite, un acelai

algoritm opereaz n timpi de execuie diferii, analiza complexitii
algoritmilor trateaz cu precdere dou cazuri:
Cazul cel mai defavorabil are durata maxim de execuie

Cazul mediu se consider drept raportul ntre suma timpilor
necesari execuiei tuturor seturilor de date posibile i numrul
Etapele analizei algoritmilor
acestora. ns, marea majoritate a algoritmilor au un numr infinit

de seturi de date, deci acest caz nu poate fi analizat.
Un algoritm este considerat eficient dac necesit un volum rezonabil de

resurse de calcul.
Timpul de execuie
n continuare, vom nota cu T(|x|) timpul de execuie al unui algoritm
relativ la instana x I. Pentru a estima timpul de execuie este necesar a
se stabili un model de calcul i o unitate de msur. Vom considera n
cele ce urmeaz modelul de calcul cu acces aleatoriu:
Toate instruciunile sunt executate secvenial

Fiecrei operaii elementare i se aloc o unitate de timp, indiferent
de tipul operanzilor
Timpul de acces la informaie nu este contorizat
Unitatea de msur pe baza creia vom calcula eficiena teoretic a unui

algoritm deriv din principiul invariaiei potrivit cruia dou
implementri diferite ale aceluiai algoritm nu difer n eficien cu mai
mult dect o constant multiplicativ. Adic, presupunnd ca avem dou
implementri de T1(|x|) respectiv T2(|x|) secunde pentru un caz de mrime
|x|, exist o constant pozitiv c astfel nct T1(|x|) < cT2(|x|), pentru orice
|x| suficient de mare.
Dac un algoritm necesit un timp de ordin |x| vom spune c necesit un

timp liniar sau c este un algoritm liniar. Similar, un algoritm este
ptratic, cubic, polinomial sau exponenial dac necesit timp de ordinul
|x|2, |x|3, |x|k respectiv k|x|, unde k este o constant.
31
Cazuri de analiz
Asa cum s-a mai precizat, timpul de execuie depinde de dimensiunea
datelor de intrare dar i proprietile datelor de intrare.
Cazul cel mai favorabil (CCMF) furnizeaz o margine inferioar a

timpului de execuie. Acest caz e mai puin util n analiza eficienei
algoritmilor ns permite identificarea algoritmilor ineficieni acei
algoritmi care au un timp de execuie mare i n cel mai favorabil caz.
Cazul cel mai defavorabil (CCMD) reprezint cel mai mare timp de
execuie furniznd limita superioar pentru acesta. n analiza algoritmilor,
marginea superioar este mai important dect marginea inferioar.
n practic cazurile extreme (CCMF i CCMD) se ntlnesc rar, astfel c

analiza acestor cazuri nu furnizeaz suficient informaie despre algoritm.
Cazul mediu (CM) se bazeaz pe cunoaterea distribuiei de

probabilitate a datelor de intrare, adic pe estimarea probabilitii de
apariie a fiecreia din instanele posibile ale datelor de intrare. Timpul
mediu de execuie este valoarea medie (n sens statistic) a timpilor de
execuie corespunztori diferitelor intane ale datelor de intrare.
Timpul mediu de execuie reprezint o valoare medie a timpilor de

execuie calculat n raport cu distribuia de probabilitate a datelor de
intrare. Stabilirea acestei distribuii de probabilitate presupune mprirea
mulimii instanelor posibile n clase astfel nct pentru instane din
aceeai clas numrul de operaii efectuate s fie acelai.
Datorit dificultilor ce pot interveni n stabilirea timpului mediu i

datorit faptului c, de regul, acesta difer de timpul n cazul cel mai
defavorabil doar prin valori ale constantelor implicate, de regul analiza
algoritmilor se rezum la estimarea timpului de execuie pentru cazul cel
mai defavorabil.
Ipoteze de estimare pentru cazul mediu:
- Datele de intrare pot fi grupate n clase dup timpii lor de execuie

- Exist un numr finit de astfel de clase (m)
32
- Probabilitatea de aparitie a unor date din clasa k este Pk

- Timpul de execuie al algoritmului pentru date de intrare
aparinnd clasei k este Tk(|x|)
n aceste ipoteze de calcul, timpul mediu de execuie este:
Tmediu(|x|) = P1T1(|x|) + ... + PmTm(|x|)
Dac probabilitatea de apariie este aceeai pentru toate clasele (cazuri

echiprobabile) atunci:
1

5 31 |4|

1
Tmediu(|x|) =
Analiza algoritmilor nerecursivi

Un algoritm poate fi recursiv sau nerecursiv. Nu este ntotdeauna necesar
s se contorizeze toate costurile instruciunilor unui algoritm pentru a se
determina timpul de execuie. De regul, este suficient s se estimeze
doar operaia dominant operaia cu cel mai mare cost sau cea mai
repetitiv.
Analiza algoritmilor nerecursivi implic urmtorii pai:
- Se stabilete dimensiunea datelor de intrare

- Se identific operaia dominant a algoritmului i numrul de
execuii ale acesteia
- Se determin (n funcie de dimensiunea i de valorile datelor de
intrare) cele 3 cazuri de analiz: CCMF, CCMD i CM. Dac
execuia operaiei dominante e diferit n aceste cazuri, atunci
aceast operaie este analizat separat
- Se determin expresia matematic a funciei ce nsumeaz
numrul de execuii ale operaiei dominante. Aceast expresie d
ordinul de complexitate al algoritmului
Exemplificare. Sortarea prin inserie
Intrare: un vector de elemente x = v[1] ... v[n]
33
Ieire: o permutare v[(1)], ..., v[(n)] astfel nct: v[(1)] < ... < v[(n)]
Dimensiunea problemei: |x| = n
Algoritm Timp Repetri

execuie
1. for i 2,n do c1 + c2n+c3(n-1) 1
2. key v[i] c4 n-1

58 67 +1
c5

3. j i-1 n -1

58 67
c6
4. while((j>0)and(v[j]> key))do

58 67
c7
5. v[j+1] v[j] c8
6. j j-1
7. endwhile
8. v[j+1] key c9 n-1
9. endfor
S se considere pentru studiu de caz vectorul (8, 1, 4, 9, 2, 6)
(8, 1, 4, 9, 2, 6) (1, 8, 4, 9, 2, 6) (1, 4, 8, 9, 2, 6) (1, 4, 8, 9, 2, 6)

(1, 2, 4, 8, 9, 6) (1, 2, 4, 6, 8, 9)
T(n) = c1 + c2n + c3(n-1) + c4(n-1) + c5(n-1) + c6

5867 + 1 + c7

58 67 + c8
58 67 + c9(n-1)
CCMF: tabloul este sortat (i)=0, i=2, T(n) = k1n + k2.
CCMD: tabloul este sortat n ordine invers (descresctoare) (i)=i,

i=2, T(n) = c1 + c2n + (c3 + c4 + c5 + c6 + c9)(n-1) + (c6 + c7 +
c8)
58 67 = c1 + c2n + k1(n-1) + k3: 1<= k1 + k2n + k3n2

8
CM: toate permutrile au aceeai probabilitate de apariie. Timpul de

execuie n acest caz este asemntor ca n cazul CCMD, deoarece n
medie (i)=i/2 (n general, pentru un element oarecare v[i] avem n medie
jumtate de elemente din vector mai mari dect el i jumatate mai mici,
deci n medie ar trebui s parcurgem jumatate de vectorul v[1... i-1]
pentru a-l insera n poziia corect.
34
Exemplificare. Considerm problema apartenenei unui element la un

vector (cutarea liniar). Considerm v[1...n] un vector de n elemente i
cautm s reinem n variabila gasit apartenea elementului x la vector.

execuie
1. gasit false c1 1
2. i 1 c2 1
3. while (!gasit) and (i<=n) do c3 1(n)+1
4. if (v[i]=x) c4 1(n)
5. then gasit true c5 2(n)
c6 3(n)
6. else gasit false
7. endif
8. endwhile
9. return gasit
i n acest caz timpul de execuie depinde de valorile din tabloul de

intrare. Vom face o analiz pe toate cele trei cazuri:
Cazul cel mai favorabil CCMF cnd elementul x aparine vectorului i

v[1] = x
Cazul mediu CM cnd elementul x aparine vectorului i v[k] = x, k >1
Cazul cel mai defavorabil CCMD cnd elementul x nu aparine

vectorului.
CCMF CM CCMD
1(n) 1 k n
2(n) 1 1 0
3(n) 0 k-1 n
Marginile timpului de execuie sunt date de cazul cel mai favorabil

(limita inferioar) i cazul cel mai defavorabil (limita superioar).
c1+ c2 + c3 + c4 + c5 T(|x|) c1 + c2 + (n+1)c3 + nc4 + nc6 k1 T(|x|)

k2n + k3
35
Obinem c limita inferioar este o constant i c limita superioar

depinde liniar de dimensiunea problemei.
Pentru calcularea timpului mediu, ipotezele de calcul sunt:
- Probabilitatea ca x s fie n tablou este p

- Probabilitatea ca x s nu fie n tablou este 1 p
- Probabilitatea ca x s se afle pe poziia k n tablou este p/n.
elementul x s fie n tablou (x = v[k], = = >>>>>

1, ) + probabilitatea ca
Complexitatea pentru cazul mediu se definete ca fiind probabilitatea ca
elementul x s nu fie n tablou:
Tmediu(|x|) = :1 + 2 + < + 1 - = :1 8< + 8. Pentru p =

? ? ? ? ?
0.5 obinem Tmediu(|x|) = 3/4n + .
Deci timpul mediu de execuie pentru algoritmul de cutare secvenial

depinde liniar de dimensiunea datelor de intrare.
Din formula timpului mediu putem s determinm formulele pentru

timpul de execuie n cazul n care elementul se afl n tablou: p=1:
+1
3@A[] |4| =
2
ceea ce se poate interpreta astfel: n cazul aparteneei elementului la
vector, algoritmul parcurge n medie jumtate din vector.
n cazul non-aparteneei elementului la vector (cazul cel mai defavorabil)

avem p=0, ceea ce implic:
3@A[] |4| = 3DDEF |4| = n
36

Scopul principal al analizei eficienei algoritmilor este acela de a
identifica modul n care timpul de execuie crete odata cu creterea
dimensiunii problemei. Pentru aceasta trebuie s se identifice:
- Ordinul de cretere al timpului de execuie

- Clasa de eficien (complexitatea) algoritmului
n analiza ordinului de cretere trebuie s se identifice expresia

termenului dominant.
Definiie. Numim termen dominant, termenul din expresia ordinului de

cretere care devine semnificativ mai mare cnd dimensiunea problemei
crete. Astfel, el discteaz comportamentul algoritmului, pe date de
intrare de dimensiune mare.
Exemple de expresii pentru timp de execuie (n bold este scris termenul

dominant)
- T1(n) = an+b
- T2(n) = alogn+b
- T3(n) = an2 + bn + c
- T4(n) = an + bn + c
Ordinul de cretere
Caracterizeaz creterea termenului dominant din expresia timpului de
execuie n raport cu dimensiunea problemei. Mai precis, ordinul de
cretere cuantific creterea termenului dominant cnd dimensiunea
problemei crete de k ori.
Exemple:
T1(n) = an T1(kn)= kan = kT1(n) cretere liniar

T2(n) = alogn T2(kn) = alog(kn) = a(logk + logn) = alogk + T2(n)

cretere logaritmic
T3(n) = an2 T3(kn) = a(kn)2 = ak2 an2 = ak2T3(n) cretere ptratic
T4(n) = an T4(kn) = akn = (an)k = T4(n)k cretere exponenial
Prin intermediul ordinului de cretere putem compara doi algoritmi
- Compararea se realizeaz pe seturi de date de dimensiuni mari

valori mari (analiza asimptotic)
- Algoritmul cu ordinul de cretere mai mic este mai eficient
- Pentru a compara ordinele de cretere a doi timpi de execuie
T1(n) i T2(n) se calculeaz limJ
%K
%L
:
o Dac lim = 0, T1(n) are ordinul de cretere mai mic dect
T2(n)
o Dac lim = c, c>0 contant, T1(n) i T2(n) au acelai
ordin de cretere
o Dac lim = , T2(n) are ordinul de cretere mai mic dect
T1(n)
Formule utile pentru determinarea ordinului de cretere

5 1 = - complexitate liniar

5 7 =

8
- complexitate ptratic

5 7 M =
NOK
M
- complexitate polinomial

5 =
=
M POK Q
MQ
- complexitate exponenial

5
S
=
5

5 S

5 T
= T
5

5M 1 = = + 1
lnM5 M = M5 lnM
38
Exerciii
naturale
5 7 . Dimensiunea acestei probleme poate fi considerat n.
Exerciiu 1. Considerm problema calculrii sumei primelor n numere

execuie
1. suma 0 c1 1
2. i 0 c2 1
3. while (i < n) do c3 n +1
4. i i+1 c4 n
c5 n
5. suma suma + i
6. endwhile
7. return suma
Obinem c T(|x|) = c1 + c2 + (n-1)c3 + nc4 + nc5 = nk1 + k2 deci timpul

de execuie depinde liniar de dimensiunea datelor de intrare, adic |x|
= n.
Exerciiu 2. Considerm problema nmulirii a dou matrici A(m,n) i

B(n, p). n acest caz |x| = (m, n, p).
Algoritm Timp execuie Repetri

1. for i 1, m do c1 + (m+1)c2 + mc3 1
2. for j 1, p do c4 + (p+1)c5 + pc6 m
3. c[i,j] 0 c7 mp
c8 + (p+1)c9 + pc10 mp
4. for k 1, n do
c5 mpn
5. c[i,j]c[i,j]+ a[i,k]*b[k,j]
6. endfor
7. endfor
8. endfor
Se poate lesne verifica c T(|x|) = mnpk1 + mpk2 + mk3 + k4.
Exerciiu 3. Considerm problema determinrii valorii minime dintr-un

vector de n elemente. Dimensiunea problemei este dat de numrul de
elemente din vector, |x| = n.
39

1. min vect[0] c1 1
2. for i 1, n-1 do c2 + nc3 + (n-1)c4 1
3. if (min > vect[i]) then c5 n-1
4. min vect[i] c6 (n)
5. endif
6. endfor
7. return min
Spre deosebire de cazurile anterioare, timpul de execuie al acestui

algoritm nu poate fi stabilit cu certitudine, el depinznd de valorile
tabloului de intrare. Cazul cel mai favorabil este atunci cnd minumul se
afl pe prima poziie in vector. n acest caz intruciunea 4. nu se va mai
executa i avem (n) = 0. Cazul cel mai defavorabil este cnd minimul se
afl pe ultima poziie n tablou. n acest caz (n) = n-1. n ambele cazuri,
att limita inferioar ct i limita superioar depind liniar de dimensiunea
problemei, deci T(|x|) = k1n + k2.
Exerciiu 4. S se defineasc un algoritm care stabileste dac un vector

are numai elemente distincte.

execuie
1. i 1 c1 1
2. j 2 c2 1
3. gasit false c3 1
4. while (i<n) and (!gasit) do c4 1(n)
c5 1(n)-1
5. j i+1
c6 2(n)
6. while (j<=n) and (!gasit)
c7 2(n)-1
7. if (v[i] = v[j]) then
c8 3(n)
8. gasit true
9. endif c8 2(n)-1
10. j j+1
11. endwhile c9 1(n)-1
12. i i+1
13. endwhile
14. return gasit
40
Operaia dominant a algoritmului este comparaia de pe rndul 6)

deoarece este cea mai imbricat operaie a algoritmului (cea mai
repetitiv).
CCMD: depinde de valorile din vectorul v i avem dou posibiliti:
- vectorul v are numai elemente distincte

- ultimele dou elemente din vector sunt egale
n acest caz avem: 2(n) = n + (n-1) + ... + 2 = Q8

5W 7 =
5W
Q8
Q8

5W 7 = 2
Q8 Q
8
= k1n2 + k2n + k3 complexitate ptratic
Exerciiu 5. S se scrie algoritmul de determinare a numrului de bii din

reprezentarea binar a unui ntreg.

1. no 1 c1 1
2. while (n>1) do c2 1(n)+1
3. no no+1 c3 1(n)
4. n n/2 c4 1(n)
5. endwhile
6. return no
CCMF: n =1 (n)=0
CM: (n) = log2n
n medie, intructiunea while (instruciunea dominant) se execut de

log2n +1 ori.
Exerciiu 6. S se defineasc i s se analizeze algoritmul de cutare al

unui element ntr-un vector folosind metoda fanionului.
Exerciiu 7. S se analizeze timpul de execuie al algoritmului de sortare

prin interschimbare bubble-sort.
41

execuie
Q

5 7 + 1
1. for i 1, n-1 do k1 n-1
Q

5 7 + 1
2. for j i+1, n do k2
3. if (v[i]>v[j]) then c3
4. v[i] v[j] k4 (n)
5. endif
6. endfor
7. endfor
cretere este Q

5 7 + 1 TX = c3
5 7 1 = c3 [(n-2) + (n-3)
Operaia dominant este compararea de la linia 3). Deci, ordinul de
Q
+ ... + (n-n+1)] = c3[ (n-2)(n-1)/2] - cretere ptratic
42
Notaii asimptotice
Notaii asimptotice
n general, se utilizeaz analiza asimptotic atunci cnd se caut s se
evalueze comparativ mai muli algoritmi, urmrindu-se astfel gruparea
algoritmilor n clase n funcie de ordinul de cretere al timpului de
execuie. Acest tip de analiz a fost definit pentru:
- analiza algoritmilor pentru seturi de intrare de dimensiuni mari,

fr a se lua n calcul eventualele constante ce intervin n
expresiile detaliate ale timpilor de execuie.
- estimarea timpului de execuie atunci cnd dimensiunea datelor
de intrare crete nelimitat
Figura 2 Analiza asimptotic a algoritmilor
Astfel, un algoritm care este considerat asimptotic mai eficient este o

alegere bun i n cazul seturilor de date de dimensiune mic ct i pentru
date de dimensiuni mari. Pentru formalizarea acestei analize s-au definit
un set de clase de funcii i notaii asociate.
Notaii asimptotice
Notaia O
Considerm un algoritm i o funcie t: N R+2 astfel nct o
implementare a algoritmului s necesite t(n) uniti de timp pentru a
executa algoritmul pentru o instan de dimensiune n. Aa cum spune
Principiul invariaiei, orice implementare a algoritmului va necesita un
timp n ordinul lui t.
Definiie. Fie f: N R+ o funcie oarecare. Definim O(f) astfel:
O(f(n)) = "Y: [ \ ; T \ , W [ . . W : Y Td }
Citim O(f) ca ordinul lui f aceasta fiind mulimea tuturor funciilor g

mrginite superior de un multiplu real pozitiv (c) pentru valori ale
argumentului suficient de mari (n n0). Prin aceast notaie spunem c
funciile g cresc la fel de repede sau strict mai lent dect funcia f. Scriem
c g este n ordinul lui f sau g este n O(f) astfel: g O(f) sau g(n)
O(f(n)), pentru n n0.
Intuitiv, faptul c g(n) O(f(n)) nseamn c g(n) crete asimptotic cel

mult la fel de repede ca f(n). Aceast clas de funcii permite descrierea
algoritmilor n cazul cel mai defavorabil.
Observaie. O condiie suficient ca o funcie f s dea o comportare

asimptotic pentru o funcie g const n existena unei constante n0 a.. n
n0 i f(n) >0 s obinem c exist limJ i c aceasta este finit
e
(pozitiv, nu neaprat nenul).
Aceasta condiie nu este ns i necesar. De exemplu, s considerm

g(n) = sin(n). Avem |g(n)| = |sin(n)| 1. Pentru n0 = 0 i c=1, f(n)=1
obinem g(n) cf(n), deci g O(1) dar limJ
fgh

nu exist.
Convenim s vorbim despre ordinul lui f chiar i atunci cnd valoarea lui
f(n) este negativ sau nedefinit pentru anumite valori n < n0. De
2 *
Prin N notm mulimea numerelor naturale, N= {0, 1, 2, ...} i N mulimea numerelor
*
naturale strict pozitive, N = {1, 2, ...}, R+ notm mulimea numerelor reale pozitive i
*
R + mulimea numerelor reale strict pozitive
44
Notaii asimptotice

ie
exemplu, vom vorbi despre ordinul lui chiar dac n punctele n=0 i
n=1 funcia nu este definit.
Pentru un algoritm care necesit t(n) uniti de timp, spunem c timpul de

timpul de execuie este n ordinul lui f dac t(n) O(f(n)). n general se
caut s se gaseasc cea mai simpl funcie f(n) a. . t(n) O(f(n)).
Pentru a demonstra c g O(f) trebuie gsit pentru c R+ , n0 N a. .

n n0: g(n) > cf(n)
Notaia asimptotic definete o relaie de ordine partial ntre funcii i

deci, ntre eficiena relativ a diferiilor algoritmi care rezolv o aceeai
problem.
Figura 3 Reprezentarea grafic pentru g(n) O(f(n))
Interpretarea algebric a notaiei asimptotice Pentru oricare f, g: N

R+ se definete relaia binar f g dac O(f) O(g). Relaia este o
relaie de ordine parial pe mulimea funciilor definite pe N cu valori in
R+. Similar se definete relaia de echivalen f = g dac O(f) = O(g).
45
Notaii asimptotice
De exemplu, avem log n = lg n = ln n deoarece O(log n) = O(lg n) = O(ln

n)3.
Dac notam cu O(k) ordinul funciilor mrginite superior de o constant

avem urmtoarea ierarhie:
O(k) O(logn) O(n) O(n logn) O(n2) O(n3) ... O(nk) ...
O(kn) O(n!) O(nn)
ordin constant ordin logaritmic ordin liniar ordin patratic

ordin cubic ordin polinomial ordin exponential ordin factorial
Aceast ierahizare corespunde unei clasificri a algoritmilor dup

performana acestora. Astfel, un algoritm polinomial este ntotdeauna
preferat unuia exponenial.
Se poate ntmpla ca timpul de execuie al unui algoritm sa depind

simultan de mai muli parametri. De exemplu, algoritmii care opereaz cu
grafuri i care depind att de numrul de vrfuri ct si de numrul de
muchii ale structurii. n acest caz, pentru o funcie arbitrar f: N N
R+ avem:
O(f) = "Y: [ [ \ |T \ , W , kW [ . . W , k
kW : Y, k Td, k }
Notaia O are urmtoarele proprieti:
1) Dac t(n) = aknk + ak-1nk-1 + ... + a1n + a0, ak >0 atunci t(n)
O(np) pentru p k.
2) f(n) O(f(n)) reflexivitate
3
Remember. Funcia logaritmic
X
Fie a >0 un numr real pozitiv. Considerm ecuaia exponenial a = N. Aceast
ecuaie are o soluie unic determinat x = logaN. Deci logaritmul unui numr real
pozitiv este exponentul la care trebuie ridicat baza pentru a obine numrul dat.
log 10 N = lg N logaritm zecimal
loge N = ln N logaritm natural (folosit n rezolvarea unor probleme de fizic, e = 2,71
numrul lui Euler)
46
Notaii asimptotice
3) dac f(n) O(h(n)) i h(n) O(g(n)) atunci f(n) O(g(n))

tranzitivitate
4) O(f(n) + g(n)) = O(max(f(n), g(n)))
Dem. Fie c1 R+ a.. f(n) c1 t1(n), n n1 i c2 R+ a.. g(n) c2

t2(n), n n2. Dac lum c = max(c1, c2) i n0 = max(n1, n2) n
n0, f(n) + g(n) c1 t1(n) + c2 t2(n) c( t1(n) + t2(n)) c2max(t1(n),
t2(n)) O(max(f(n), g(n))).
5) (f(n)) O(f(n)) nu e obligatoriu ca orice limit superioar s

fie i limit inferioar
Notaia
Notaia O(f) este folosit pentru a nota superior timpul necesar unui
algoritm, msurnd eficiena respectivului algoritm. Uneori este util s
estimm i limita inferioar a acestui timp:
(f) = "Y: [ \ |T \ , W [ . . W : Y Td }
Intuitiv, faptul c g(n) (f(n)) nseamn c g(n) crete asimptotic cel

e
puin la fel de repede ca f(n), adic limJ este strict pozitiv dar nu
neaprat finit.
Observm c pentru dou funcii oarecare f, g: N R+ avem f O(g)

dac i numai dac g (f).
47
Notaii asimptotice
g(n)
cf(n)
n0
Figura 4 Reprezentarea grafic pentru g(n) (f(n))
Notaia are urmtoarele proprieti:
(np), p k
2) f(n) (f(n)) - reflexivitate
3) dac f(n) (h(n)) i h(n) (g(n)) atunci f(n) (g(n))
4) (f(n)+g(n)) = (max(f(n), g(n)))
5) (f(n)) (f(n))
6) dac f(n) O(g(n)) atunci g(n) (f(n)) i reciproc
O situaie fericit este atunci cnd timpul de execuie este limitat att
superior ct i inferior de un multiplu real i pozitiv al aceleiai funcii,
aa cum se va defini n seciunea urmtoare ordinul exact al unei funcii -
(f).
Notaia
n general este dificil s se determine expresia ce definete timpul de
execuie al unui algoritm n funcie de dimensiunea datelor de intrare. De
aceea, o metod de estimare a eficienei algoritmilor const n
determinarea limitelor ntre care timpul de execuie poate varia.
48
Notaii asimptotice
Definiie. Pentru o funcie g: N R+, (f) reprezint mulimea de

funcii:
(f(n)) = "Y: [ \ ; T , T8 \ , W [ . . 0 < T d Y

T8 d , W }
Figura 5 Reprezentarea grafic pentru g(n) (f(n))
Observm c avem:
(f) = O(f) (f)
O alt remarc relativ la notaia O i este urmtoarea: pentru f, g : N

R+ dac O(f) = O(g) atunci (f) = (g).
Despre timpul de execuie al unui algoritm t(n) se spune c este de ordin

(f(n)) dac t(n) (f(n)). Din punct de vedere intuitiv, faptul c t(n)
(f(n)) nseamn c t(n) i f(n) sunt asimptotic echivalente, adic au
acelai ordin de cretere. Altfel spus:
n
lim ==
J d
unde k este o constant pozitiv.
49
Notaii asimptotice
Notaia are urmtoarele proprieti:
(nk)
Dem. ntr-adevr, din limJ = M rezult c R+ i
o
N
n0() a.. p M p < q, n> n0() => M q M + q,

o o
N N
n> n0(). Deci pentru c1 = ak - , c2 = ak + , n0 = n0() => t(n)
(nk).
2) (logan) = (logbn) oricare ar fi a, b R+, a, b 1
Dem. Proprietatea rezult din formula Yr = s i din (k
ie
ie r s
f(n)) = (f(n)). Aceast proprietate sugereaz faptul c n analiza

eficienei algoritmilor nu conteaz baza logaritmului, motiv
pentru care, de obicei, logaritmul se specific prin lg fr a mai
face referire la baza logaritmului (de obicei se consider a fi 2).
3) f(n) (f(n)) reflexivitate
4) dac f(n) (g(n)) atunci g(n) (f(n)) simetrie
Proprietile 3) i 4) sugereaz c notaia permite definirea unor
clase de echivalen: f(n) i g(n) sunt echivalente dac f(n)
(g(n)). Clasele de echivalen corespunztoare se numesc clase
de complexitate.
5) dac f(n) (h(n)), h(n) (g(n)) atunci f(n) (g(n))
tranzitivitate
6) (f(n) + g(n)) = (max(f(n), g(n))
Notaia se folosete atunci cnd se poate determina explicit expresia

timpului de execuie pentru un set de algoritmi diferii sau cnd algoritmii
analizai au acelai ordin de cretere n cazuri extreme.
Sumarizm:
- Dac g(n) O(f(n)) nseamn c pentru valori mari ale setului de

date de intrare cf(n) este o limit superioar pentru g(n) ceea ce
implic faptul c algoritmul se va comporta mai bine dect
aceast limit n marea majoritate a cazurilor.
50
Notaii asimptotice
- Dac g(n) (f(n)) nseamn c pentru valori mari ale setului de

date de intrare cf(n) este o limit inferioar pentru g(n) ceea ce
implic faptul c algoritmul se va comporta mai ru dect aceast
limit n marea majoritate a cazurilor.
- Dac g(n) (f(n)) nseamn c pentru valori mari ale setului de
date de intrare c1f(n) este limita inferioar pentru g(n) iar c2f(n)
este limita superioar algoritmul tinde s se comporte cam ca
f(n)
Proprieti ale notaiilor asimptotice de complexitate:
1) Tranzitivitate
f(n) O(h(n)), h(n) O(g(n)) f(n) O(g(n))
f(n) (h(n)), h(n) (g(n)) f(n) (g(n))
f(n) (h(n)), h(n) (g(n)) f(n) (g(n))
2) Reflexivitate
f(n) O(f(n))
f(n) (f(n))
f(n) (f(n))
3) Simetria
f(n) (g(n)) atunci g(n) (f(n))
4) Antisimetria
f(n) O(g(n)) atunci g(n) (f(n))
5) Altele
f(n) (g(n)) dac i numai dac f(n) O(g(n)) i f(n) (g(n))
51
Notaii asimptotice
Analiza asimptotic a principalelor structuri de

prelucrare
Considerm problema dterminrii ordinului de complexitate n cazul cel
mai defavorabil pentru urmtoarele structuri algoritmice: secvenial,
alternativ, repetitiv.
Presupunem c avem o structura secvenial construit din prelucrrile

P1, ..., Pk i fiecare are ordinul de complexitate O(fi(n)). Atunci ordinul de
complexitate al algoritmului este O(f1(n) + ... + fk(n)) = O(max(f1(n), ...,
fk(n)).
Dac evaluarea condiiei unei structuri alternative are cost constant iar
prelucrrile celor dou variante au ordinele de complexitate O(f1(n)) i
O(f2(n)) atunci costul structurii alternative ar fi O(max(f1(n), f2(n)).
n cazul unei structuri repetitive, pentru a determina costul de

complexitate n cazul cel mai defavorabil se consider numrul maxim de
iteraii. Dac acesta este n iar dac n corpul ciclului prelucrrile sunt de
ordin constant, atunci se obine ordinul O(n). n cazul ciclului dublu, dac
att pentru ciclul interior ct i pentru ciclul exterior limitele variaz ntre
1 i n atunci se obine de regul o complexitate ptratic O(n2). Dac
ns, limitele ciclului interior se modific atunci este posibil s se obin
alt ordin.
m 1
for i 1, n do
m 2*m
for j 1, m do
//prelucrare de ordin O(1)
endfor
endfor
n acest caz n =
52
+ 1 t2
Marea majoritate a algoritmilor se ncadreaz n una din urmtoarele

clase de complexitate:
52
Notaii asimptotice
- clas de complexitate unitar O(1) exemple: operaii aritmetice,

cutare folosind tabelele de dispersie
- clas de complexitate algoritmic O(lgn) exemplu: algoritmul
de cutare binar
- clas de complexitate liniar O(n) exemple: algoritm de cutare
secvenial, suma unui ir
- clas de complexitate liniar O(n lgn) exemple: algoritmi de
sortare rapid, interclasare
- clas de complexitate ptratic O(n2) exemple: algoritmi de
sortare neperformani: sortare prin inserie, sortare prin metoda
bulelor, parcurgeri de tablouri ptratice de ordin n
- clas de complexitate cubic O(n3) exemplu: algoritmul de
nmulire a dou matrici de dimensiune n
- clas de complexitate exponenial O(2n) exemplu: algoritmi de
prelucrare a tuturor submulimilor unei mulimi de n elemente
- clas de complexitate factorial O(n!) exemplu: generarea
tuturor permutrilor unei mulimi de n elemente
n ierarhizarea claselor dup ordinul de complexitate sunt utile

urmtoarele limite:
limJ =0, limJ =0, limJ =0, limJ

ie s N uP uP
N uP P !
=0
Metode generale de calcul pentru indicatorii de complexitate
Pentru calculul funciei caracteristice i ncadrarea acesteia ntr-o clas de

complexitate se folosesc urmtoarele proprieti de baz ale notaiilor
asimptotice:
- Compunerea
- dac algoritmul este compus din dou secvene cu timpii de

execuie caracterizai de funciile f(n) i g(n) atunci algoritmul va
avea ordinul max(f +g); (f + g) = (max(f, g))
- dac un algoritm apeleaz o secven de ordin f(n) de k ori, atunci
algoritmul va avea tot ordinul f(n): (k f(n)) = (f(n))
53
Notaii asimptotice
- dac un algoritm apeleaz o secven de ordin f(n) ntr-un ciclu

care se execut de g(n) ori, atunci algoritmul va avea ordinul
(f(n)g(n))
Exemple de limite pentru determinarea aparteneei la o clas:
dac limJ e = 0 atunci f(n)=o(g(n)), adic f(n) = O(g(n)) i

-
dac limJ \ atunci f(n) = (g(n))

f(n) (g(n))

e
-
dac limJ = atunci f(n)=(g(n)), adic f(n)(g(n)) i

e
-
f(n) (g(n))
Exist o serie de proprieti (se pot demonstra cu ajutorul limitelor):
- complexitatea funciilor polinomiale: dac d =

5W
4
atunci f(n) = (xn)

- pentru orice constante a, b > 0, (n+ a)k = (nk)
- pentru orice constant real a >1, dac f(n) = (g(n)) atunci af(n) =
proprietatea de liniaritate a seriilor: M5 xd= y =

a(g(n))
M5 d=
-
- dac (f) = (g) atunci (ln f) = (ln g)
54
Notaii asimptotice
Exerciii
1. S considerm f(n) = 10n i g(n)=n2. S se determine ordinele celor
dou funcii.
n f(n) g(n)
1 10 1
2 20 4
3 30 9
... ... ...
9 90 81
10 100 100
11 110 121
12 120 144
Se poate deci observa c n 10 f(n) g(n) ns pentru n >10 f(n) <

g(n). Obinem c pentru n0=10 i c=1 f(n) cg(n), deci f(n) O(g(n))
deci f= O(n2).
Sau pentru c=10 i n0=1, n n0 avem f(n) cg(n).
2. Verificai relaia f(n)= n2 + 5nlgn + 10 O(n2).

3. Fie f, g: N R+ cu f(n) = 6n3+14n2-8n+4 i g(n) = 2n3. S se
determine ordinele celor dou funcii.
Avem f(n) = 6n3+14n2-8n+4 6n3+14n3+ 8n3 +4n3 = 32n3. Deci,

pentru c=16 i n0=1 avem n n0 avem f(n) cg(n), deci f = O(2n3).
Avem g(n) = 2n3 6n3 6n3+14n2-8n+4 i obinem, pentru n0=1, c

n n0 avem g(n) f(n) deci O(g) = O(f) i anume g = O(2n3).
4. Verificai c f(n) = 3n2 + O(n2).

5. Demonstrai c urmtoarea afirmaie nu este corect f(n) = 3n
O(2n).
6. Pentru n numr natural nenul, fie:

8
f(n) = 1+ 2+ ... + n, deci f(n) = . Verificai prin inducie c f(n)
O(n2) i f(n) O(n).
55
Notaii asimptotice
8
z
g(n) = 12 + 22 + ... + n2, deci g(n) = . Verificai prin
inducie c g O(n3)
8
h(n) = 13 + 23 + ... + n3, deci h(n) = { | . Verificai prin inducie
8
c h O(n4).
@ POK Q
i(n) =
5 4
= @Q
. Verificai prin inducie c i (xn), x>1
56
Analiza complexitii algoritmi recursivi
Analiza complexitii
algoritmilor recursivi
n cazul algoritmilor recursivi, principiile de analiz au n vedere
urmtoarele aspecte:
- Stabilirea dimensiunii datelor de intrare

- Identificarea operaiei dominante i a numrului de execuii ale
acestei operaii. Dac acest numr depinde de setul de date intrare
(dimensiune sau valori) se tratateaz separat cele 3 cazuri: CCMF,
CCMD i CM
- Iniializarea relaiei de recursie pe anumite condiii iniiale i
identificarea expresiei relaiei de recursie pentru operaia
dominant. n general, determinarea formulei relaiei de recuren
se obine folosind metoda de substituie forward si backward.
Algoritmii recursivi sunt uor de implementat ns execuia lor conduce

la costuri suplimentare. La fiecare apel recursiv se plaseaz o serie de
informaii ntr-o zon de memorie special destinat, numit stiva
programului.
Exemplificare. Calculul factorialului unui numr.
function fact(n)
if (n<=1) then return 1
else return nfact(n-1)
endif
endfunction
Etapele analizei algoritmilor recursivi sunt urmtoarele:
- se stabilete dimensiunea problemei

- se identific operaia dominant
- se verific dac timpul de execuie depinde de proprietile
datelor de intrare (n acest caz se analizeaz cazul cel mai
favorabil i cazul cel mai defavorabil)
- se estimeaz timpul de execuie
n general, n cazul algoritmilor recursivi nu se poate tii a-priori cte

apeluri recursive se vor efectua.
Notnd cu t(n) timpul de execuie pentru un algoritm recursiv, vom

prezenta trei metode de calcul pentru determinarea complexitii lui t(n):
metoda iteraiei, metoda substituiei i metoda bazat pe arbori recursivi.
Aceste tehnici pornesc de la observaia c nu este important forma
funciei ci clasa de complexitate din care face parte. De asemenea, se
poate omite din calcul condiia de oprire, aceasta avnd de regula un timp
de execuie unitar.
Metoda substituiei
Aceast metod presupune identificarea formulei de recuren i
demonstrarea ei folosind inducia matematic. Metoda se poate utiliza
att pentru determinarea limitei superioare dar i a limitei inferioare a
unui algoritm. Metoda este foarte puternic dar nu poate fi aplicabil
dect problemelor pentru care se poate intui formula de recuren.
58
n general, aceast metod este folosit la algoritmii de tipul Divide et

Impera care mpart problema n k sub-probleme de dimensiune n/d i apoi
combin rezultatele obinute la subprobleme pentru a reface ntregul. De
obicei k=2 i d=2. Pentru acest tip de algoritmi expresia timpului de
execuie este:
t(n) = k t(n/d) + f(n)
unde f(n) reprezint costul procedurii de recombinare i care are un

ordin unitar de execuie.
Procesul de verificare a unei recurene de complexitate pentru expresia

timpului de execuie t(n) folosind metoda substituiei are urmtorii pai:
- intuirea unei soluii O(f(n))

- verificarea pasului iniial t(n0) = O(f(n0))
- verificarea relaiei t(n) = O(f(n)), n n0
Exist dou variante ale acestei metode: metoda substituiei nainte i

metoda substituiei napoi.
Metoda substituiei nainte

Aceast metod pornete de la un pas iniial i pe baza acestuia se
calculeaz valoarea pentru urmtorul pas. Procesul se continu pn cnd
se ghicete formula de recuren. Totui, aceast metod nu poate fi
folosit n practic deoarecere nu asigur n mod necesar identificarea
recurenei.
De exemplu, s considerm relaia t(n) = t(n-1) + n avnd condiia iniial

t(0) = 0.
Pentru n=1, t(1) = t(0) + 1 = 1
Pentru n=2, t(2) = t(1) + 2 = 3
Pentru n=3, t(3) = t(2) + 3 = 6
...
59
Pentru n, t(n) = t(n-1) + n
________________________

8
t(n) = 1+2 + 3 + .... + n = . Obinem t(n) = (n2).
Metoda substituiei napoi

n aceast variant valorile sunt substituite cu valori obinute la pasul
precedent. De exemplu, pornind de la aceeai relaie t(n) = t(n-1) + n
avnd condiia iniial t(0) = 0 avem:
t(n) = t(n-1) + n = [t(n-2) + (n-1)] + n = [[t(n-3) + (n-2)] + (n-1)] + n = ...

= t(n-k) + (n-k+1) + ... + n.

8
Pentru k =n t(n) = 0 + 1 + ... + n = . Obinem t(n) = (n2)
Pentru exemplificare vom considera n cele ce urmeaz problema cutrii

binare, aceasta fiind cea mai simpl aplicaie a metodei Divide et impera.
n esen este algoritmul dup care se caut un cuvnt n dicionar sau un
nume n cartea de telefon.
Enun: se d v[1...n] un vector ordonat cresctor i un element x i se

cere i astfel nct v[i] x < v[i+1].
Cutare secvenial Cutare binar

for i 1, n function binsearch(start, finish)
if (v[i]=x) then if (start=finish) then
return i return start
endif endif
endfor mij (start+finish+1)/2
if (x < v[mij]) then
binsearch(start, mij)
else
binsearch(mij+1, finish)
Algoritmul de cutare secvenial necesit un timp n (id+1) unde id

este poziia lui x n tablou. n cazul cel mai favorabil avem un timp de
60
execuie de ordinul (1) iar n cazul cel mai nefavorabil timpul de

execuie este de ordinul (n). Timpul mediu de execuie:
Tmediu(|x|)= x1 + + y = 1 + + = 8 =

h
n cazul cutrii binare, algoritmul necesit un timp (logn) indiferent de

poziia lui x n tablou.
Timpul de execuie este de forma:

n : < , > 1
n = ~ 2
1, = 1
i se poate demonstra folosind metoda substituiei c t(n)= O(log n)
ntr-adevr, pentru n=2 t(2) = t(1)=1 clog 2= O(log 2), c 1.
Presupunem c avem n2 = tlog 2 i demonstrm proprietatea

pentru t(n).
n = n2 T log 8 2 = T log + log 2Q = T log T

T log pentru n0 = 2 i c 1.
Metoda Iteraiei
Aceast metod transform recursia ntr-o sum i se bazeaz pe folosirea
tehnicilor de mrginire a sumelor. Conversia recurenei n sum se face
prin expandarea recursiei i exprimarea ei ca o sum de termeni
dependeni numai de n i de condiiile iniiale.
Pentru exemplificare vom considera algoritmul mergesort, care este

un algoritm de sortare prin interclasare ce folosete strategia Divide et
impera, dup cum urmeaz:
- mparte vectorul n dou jumti (divide)

- sorteaz fiecare jumtate folosind metoda sortrii prin interclasare
(impera)
- combina cei doi vectori ntr-un vector de dimensiune dubl
61
function mergesort(start, finish)

if (start < finish) then
mij (start+finish)/2
mergesort(start, mij)
mergesort(mij+1, finish)
merge(start, mij, finish)
endif
endfunction
function merge(start, mij, finish)
for i start, finish
temp[i] vect[i]
i start; k start; j mij+1
while (i mij) and (j finish) do
if (temp[i] temp[j])
then vect[k++] temp[i]
else vect[k++] temp[j]
endif
endwhile
while (i mij)
vect[k++] temp[i++]
endwhile
while (j finish)
vect[k++] temp[j++]
endwhile
endfunction
Costul nerecursiv al algoritmului este dat de funcia merge care are

ordinul (n) f(n) = (n). Costul recursiv este dat de funcia
mergesort care include 2 apeluri recursive de dimensiune n/2. Relaia
de recuren devine:
t(n) = 2t(n/2) + f(n) = 2t(n/2) + (n)
S determinm ordinul de complexitate folosind metoda iterativ:
t(1) = (1) vectorul este deja sortat
62

2W n : < = 2
n : < + 2W

2W 2 2W

2 n : < = 28 n : 8 < + 2
2 2 2

28 n : < = 2X n : X < + 28 8
28 2 2
....

2M n : < = 2M
n : < + 2M

2M 2M 2M

Recurena se termin n momentul n care ajungem la (1) deci cnd

8N
=1, deci k= logn.
t(n) = M5WL 2M N = M5WL = 1 + log 8

8
Arbori de recuren
Aceste reprezentri au urmtoarele semnificaii:
- un nivel n arbore reprezint un nivel de recursivitate

- un nod reprezint un apel recursiv
- pentru fiecare nivel de recursiviate este indicat i costul
nerecursiv al acelui nivel
- pentru fiecare nod este indicat costul nerecursiv al apelului
Pentru recursia algoritmului mergesort are un arbore cu log2n nivele,

nodul rdcin avnd un cost (n).
t(n) = (n)(1 + logn) = (n + nlogn) = (nlogn)
63
t(n) (n)
(n/2) t(n/2) t(n/2) (n/2)

log2n + 1 nivele
(n/4) t(n/4) t(n/4) t(n/4) (n/4) t(n/4) (n/4)
t(1) t(1) t(1) t(1)
(1) (1) (1) (1)
Figure 2 Arborele de recuren pentru algoritmul mergesort
Metoda Master
Metoda Master ofer o soluie direct pentru relaii de recuren de tipul:
t(n) = at(n/b) + f(n), n k, k - o constant pozitiv
unde f(n) este o funcie asimptotic pozitiv iar t(n) o funcie nenegativ.
Teorema Master stabilete dac f(n) = (nk) atunci t(n) poate fi mrginit
asimptotic astfel:
- t(n) = (nk) dac a < bk

- t(n) = (nk) dac a = b
- t(n) = (s r 4) dac a > bk
4
Remember!
m log2m
1 0
2 1
4 2
8 3
16 4
32 5
64 6
128 7
256 8
64
Aceste recurene caracterizeaz timpul de execuie al unui algoritm

Divide et impera care mparte problema n a subprobleme de dimensiune
n/b pe care le rezolv recursiv, constul necesar divizrii problemei i
recombinrii soluiei fiind f(n).
Exemplu: s considerm t(n) = 4t(n/2) + n. Conform notaiilor din

teorema Master avem a = 4 i b =2 i pentru k=1 obinem f(n) = n = (nk)
deci t(n) = (L ) = (n2).
Tehnica reducerii
Aceast tehnic folosete legtura ntre soluia unei probleme i soluia
aceleiai probleme dar pentru o instan de dimensiune mai mic. Pentru
unele probleme aceast abordare conduce la obinerea unor algoritmi mai
eficieni deoarece, uneori, este mai simplu s se specifice relaia dintre
soluia problemei de rezolvat i soluia unei probleme de dimensiune mai
mic dect s se specifice explicit modul de calcul al soluiei.
Exemplu. S considerm problema calculrii valorii expresiei xn, pentru

n=2m, m 1.
4 4, k = 1
48 =

4 8K
48 , k > 1
K
Obinem c 4 8 poate fi calculat dup urmtoarea schem:

pentru m=1, x2 = 4 8 4 8

pentru m=2, 4 8 = 4 8 4 8
L K K
pentru m=3, 4 8 = 4 8 4 8
L L
Funcia care implementeaz formula de mai sus, power2 folosete un

mecanism de calcul ascendent, n sensul c pornete de la problema de
dimensiune mai mic ctre problema de dimensiune mai mare.
function power2(x, m)
p x x
65
for i 1, m-1 do
p p p
endfor
return p
endfunction
Eficiena acestei tehnici: dac dimensiunea problemei este n = 2m atunci

t(m)=m adic t(n)=lg n.
O alt variant pentru aceeai tehnic dar cu o abordarea de sus n jos n

care dimensiunea scade cu o unitate este urmtoarea:
if (m=1) then return x x
else
p power3(x, m-1)
return p p
endif
endfunction
S considerm acum urmtoarea formul pentru calcularea puterii lui xn,
4 4, = 2
n numr par.
4 =
48 48, > 2
Se observ c n acest caz dimensiunea problemei descrete prin

mprire la 2:
if (n=2) then return x x
else
p power4(x, n div 2)
return p p
endif
endfunction
66
Algoritmii de mai sus power3 i power4 au o abordare descendent

pornind de la problema de dimensiune iniial i reducnd succesiv
dimensiunea pn cnd se ajunge la o problem suficient de simpl. Aa
cum se poate observa ambii algoritmi sunt recursivi.
Tehnica reducerii poate fi extins i n cazul unui exponent n cu valoare

natural arbitrar:
4 4, = 2
4 = 4 8 4 8 , > 2, k -

Q Q
p p p p
4 8 4 8 4, > 2, k 7k-
Funcia corespunztoare acestei formule este:
function power5(x, n)
if (n=1) then return x
else
if (n=2) then return x x
else
p power5(x, n div 2)
if (n mod 2=0) then return p p
else return p p x
endif
endif
endif
endfunction
n cazul algoritmilor recursivi, pentru estimarea timpului de execuie se

caut relaia de recuren care exprim legtura dintre timpul de execuie
corespunztor problemei iniiale i timpul de execuie corespunztor
problemei reduse. Estimarea timpului de execuie se obine prin
rezolvarea relaiei de recuren:
Pentru calculul lui n! dup formula:

1, = 1
! =
1 !, > 1
67
0, = 1
avem urmtoarea recuren:
n =
n 1 + 1, > 1
Formula de recuren pentru algoritmul power3(x, m) este:
t(2m) = t(2m-1) + 1
Aplicnd metoda substituiei napoi avem:
t(2m) = t(2m-1) + 1
t(2m-1) = t(2m-2) + 1
...
t(2) = 1
________________
t(2m) = m = lg n
Formula de recuren pentru algoritmul power4(x, n) este:

1, = 2
n =
2n/2 + 1, > 2
Aplicnd metoda substituiei napoi avem:
t(n) = 2t(n/2) + 20
2t(n/2) = 22t(n/22) + 21
22t(n/22) = 23t(n/23) + 22
...
2kt(n/2k-1) = 2kt(n/2k) + 2k-1
Pentru k = lg n avem t(n) = 2lg n + 1 + 2 + ... + 2lg n-1 deci t(n) = O(2ieL )
= O(n).
Aplicaie a tehnicii de reducere

Generarea celor n! permutri ale mulimii {1, 2, ..., n} Cele k!
permutri ale mulimii {1, 2, ... , k} pot fi obinute din cele (k-1)!
permutri ale mulimii {1, 2, ... , k-1} prin plasarea celui de-al k-lea
element succesiv pe prima, pe a doua, ..., pe a k-a poziie n submulimea
de k-1 elemente. Plasarea elementului de pe poziia k pe poziia i se face
prin interschimbarea elementului de pe poziia k cu elementul de pe
poziia i.
68
123
321 132 123
231 321 312 132 213 123
function permut(k)
if (k=1) then write v[1...n]
else
for i 1,k do
v[i] v[k]
perumt(k-1)
v[k] v[i]
endfor
endif
endfunction
0, = = 1
Formula de recuren pentru acest algoritm este:
n= =
=n= 1 + 2 , = > 1
Aplicnd metoda substituiei napoi obinem:

t(k) = k(t(k-1) + 2)
kt(k-1) = k(k-1)(t(k-2) + 2)
k(k-1)t(k-2) = k(k-1)(k-2)(t(k-3)+2)
....
k(k-1)...3t(2) = k(k-1)...2(t(1)+2)
i avem: t(k) = k! deci t(n)= O(n!)
69
1) Demonstrai c t(n) = O(n) pentru: t(n) = 2n2 + 1.

Exerciii
Presupunem t(n/2) = O(n/2) c >0 i n0 N a.. t(n/2) c(n/2)

Demonstrnd pentru n obinem:
t(n) 2c (n/2) + 1 = cn +1 care nu este n mod necesar mai mic
dect cn
Dac ns lum c, b >0 a.. t(n/1) c(n/2) b obinem t(n)
2) Demonstrai c t(n) = O(logn log(logn)) pentru t(n) = 2n

2c(n/2) b = cn b cn
+logn.
Lum m = logn i avem: t(m) = 2t(m/2) + logm. Trebuie s
demonstrm c t(m) = O(m logm).
t(m) 2cm/2 (log(m/2)) + logm = cm(logm + log2-1) + logm = cm
logm 2cm +logm = cm logm 2c + logm cm logm + m, pentru
c>1
3) S se determine ordinul de cretere pentru problema Turnurilor
din Hanoi care are un timp de execuie de forma:
n 1 + 1 + n 1 , > 1
n =
1, = 1
Prin expandarea expresiei se obine:
1)+1) + 2 + 1 = 8t(n-1) + 4 + 2 + 1 = ... = Q

5W 2 = 2 1
t(n) = 2t(n-1) + 1 = 2(2t(n-2)+1) + 1 = 4t(n-1) + 2 + 1 = 4(2t(n-

n
Obinem c t(n) = O(2n).
4) Considerm algoritmul mergesort pentru care timpul de

execuie este de forma:
t(n) = 2t(n/2) + (n)
S se demonstreze prin metoda substituiei c ordinul de
complexitate t(n) = (n) (1 + logn) = (n + n logn)
Dem. Pentru n=1 avem t(1) = 1 = (1).
Presupunem adevrat pentru n/2 i vom avea c>0 i n >0 a..
t(n/2) c(n/2 + n/2 log(n/2))
70
t(n) cn + cn(log(n/2)) + (n) = cn + cnlogn cn + (n) =

cnlogn + (n) = (nlogn) + (n) = (n + nlogn)
5) S se determine ordinul de complexitate prin metoda substituiei
pentru t(n) = t(n-1) + 1 cu t(0) = 0 condiie iniial.
Dem. Folosind substituia napoi obinem:
t(n-1) = t(n 2) + 1 t(n) = t(n-2) + 1 + 1 = t(n- 2) + 2 = t(n 3)
+ 3 = ... = t(n k) + k
Pentru k = n t(n) = t(0) + n = n t(n) = (n)
6) S se determine ordinul de complexitate pentru relaia de
recuren:
t(n) = 2t(n/2) + n, cu t(1) = 1.

t(n) = 2t(n/2) + n = 2[2t(n/4) + n/2] + n = 22t(8L ) + 218K + 8

8 8L 8 8 8 8
t(n) = 2[2[2t( )+ ] + ]+n = 23t( ) + 22 L + 21 + n

8N 8
Pentru = 1 adic k = log2n obinem t( N) = t(1) = 1
Deci t(n) =
M5W 2 8N =
L M
n(1 + log2n) = n + nlog2n = ( n +
nlog2n) = (nlog2n)
71
Analiza algoritmilor. Studiu de caz
Algoritmi recursivi. Studiu de

caz
Problema Turnurilor din Hanoi
Aceast problem are o rezolvare suficient de simpl i de intuitiv
pentru a permite analiza de complexitate i a demonstra corectitudinea
algoritmului.
O legend Brahman spune c, de la nceputul lumii, exist undeva 3

turnuri de filde. Pe unul dintre turnuri se afla iniial o stiv format din
64 de discuri din aur cu diametre diferite, aezate n ordinea
descresctoare a diametrelor, de la baza turnului spre vrf. Preoii
brahmani au sarcina de a deplasa stiva de discuri pe un alt turn astfe
nct:
- doar un disc, i anume cel aflat n vrful unui turn poate fi

deplasat la un moment dat pe alt turn
- orice disc trebuie s se sprijine pe baza unui turn sau pe un disc cu
diametrul mai mare dect al lui
Lumea se va sfri cnd preoii i vor termina treaba!
Soluia este recursiv, fiind descris cu ajutorul unei funcii de 4

parametri: n numrul de discuri, X, Y i Z trei discuri generice.
function hanoi(n, X, Y, Z)
if (n 1) then
hanoi(n-1, X, Z, Y)
hanoi(1, X, Y, _)
hanoi(n-1, Z, Y, X)
endif
endfunction
Pentru hanoi(4, A, B, C) cele 15 deplasri efectuate de algoritm

sunt listate mai jos:
move disk from top of A on C
move disk from top of A on B
move disk from top of C on B
move disk from top of B on A
move disk from top of B on C
move disk from top of C on A
move disk from top of B on A
S calculm complexitatea algoritmului, adic s determinm numrul de

discuri care se deplaseaz.
Conform algoritmului, problema se poate descrie prin intermediul

urmtoarei recurene:
move(n) = move(n-1) + 1 + move(n-1) = 2move(n-1) + 1
S rezolvm recursia folosind metoda substituiei inainte:
73
pentru n > 1:
move(2) = 2move(1) + 1 = 3
move(3) = 2move(2) + 1 = 7
move(4) = 2move(3) + 1 = 15
...
Nu ajungem prea departe ... s ncercam metoda substituiei napoi:
move(n) = 2move(n-1) + 1 = 2[2move(n-2) + 1] + 1
= 22move(n-2) + 21 + 20
= 2[2[2move(n-3) + 1] + 1] + 1
= 23move(n-3) + 22 + 21 + 20
.........................................
= 2kmove(n-k) + 2k-1 + ... + 21 + 20
Pentru n k = 1 obinem k = n 1. Deci:
move(n) = 2n-1move(1) + 2n-2 + ... + 21 + 20
= 2n-1 + 2n-2 + ... + 21 + 20 = Q

5W 2 = 2 1

n
Prin inducie demonstrm acum c move(n) = 2n 1.
Pentru n=1 avem move(1) = 1
Presupunem adevrat recurena pentru n-1 i o demostrm pentru n.
move(n) = 2move(n-1) + 1 = 2[2n-1 1] + 1 = 2n 1
deci move(n) = (2n 1) = (2n)
Arborele de recursie corespunztor problemei Turnurilor din Hanoi este:
74
Figure 3 Arborele de recursie pentru problema Turnurilor din Hanoi
75
NP-completitudine
NP-completitudine
n analiza complexitii, cel mai important aspect care intereseaz att pe
teoreticieni ct i pe cei care care implementeaz este acela de a stabili
dac, pentru o anumit problem, exist un algoritm polinomial care s o
rezolve.
Problemele rezolvabile n timp polinomial sunt probleme considerate

accesibile i exist macar trei argumente n favoarea acestei afirmaii:
n general gradul funciei polinomiale este un numr relativ mic,

existnd puine probleme al cror ordin de complexitate s fie
(nk) cu k 100.
Pentru multe modele de calcul, o problem care poate fi rezolvat
n timp polinomial pe un anumit model de calcul, va putea fi
rezolvata n timp polinomial pe orice alt model de calcul.
Clasa problemelor polinomiale este nchis la operaii de tipul
adunare, nmulire sau compunere. De exemplu, un algoritm care
apeleaz de un numr constant de ori subprograme polinomiale
este tot un algoritm cu ordin de complexitate polinomial.
n realitate, teoria NP-completitudinii este util chiar i atunci cnd

produce rezultate negative: Atunci cnd imposibilul este eliminat, ceea ce
rmne, orict de improbabil ar fi, este adevrul (Arthur Conan Doyle).
Teoria NP-completitudinii permite concentrarea eforturilor ntr-o manier
productiv prin faptul c permite s se stabileasc c exist puine anse
pentru a gsi o soluie eficient la o problem dat. Cu alte cuvinte,
atunci cnd nu reuete s demonstreze c o problem e greu de rezolvat,
atunci nseamn c avem anse de a gsi un algoritm eficient de
rezolvare. Mai mult dect att, teoria NP-completitudinii ne permite s
identificm care sunt caracteristicile care fac ca o problem s fie dificil.
O problem abstract P se definete ca fiind o relaie binar ntre

mulimea I a instanelor problemei i mulimea S a soluiilor problemei.
Teoria NP-completitudinii vizeaz numai problemele de decizie, i
NP-completitdine
anume problemele care au soluii de tipul da/nu. n aceast aseriune, o

problem decizie este considerat ca fiind o funcie definit pe mulimea
I a instanelor cu valori n mulimea {da, nu}.
Exemple de probleme de decizie:
1. Fiind dat un graf G = (V, N), exist un drum n acest graf de lungime
mai mic dect k?
2. Fiind dat un graf G = (V, N) se pot colora nodurile din V cu m culori

astfel nct dou noduri adiacente s nu aibe aceeai culoare?
Din definiia problemelor de decizie observm c ceea ce conteaz este

doar existena soluiei. Aceast restricie aplicat problemelor de decizie
este justificat prin faptul c celelalte probleme care nu intr n categoria
problemelor de decizie, ca de exemplu problemele de optimizare, pot fi
uor transformate n probleme de decizie.
Rezolvarea problemelor de decizie constituie forma standard utilizat de

teoria calculabilitii. Dei marea majoritate a problemelor sunt probleme
de optimizare, scopul teoriei complexitii este de a clasifica problemele
de decizie n funcie de dificultatea gradului lor de soluionare. Se poate
arta ca orice problem de optimizare se poate transforma ntr-o
problem de decizie.
n literatura de specialitate exist mai multe categorii de complexitate. n

cele ce urmeaz le vom aborda doar pe cele mai importante.
Vom defini clasa de complexitate P ca fiind mulimea problemelor de

decizie care sunt rezolvabile n timp polinomial. Este aa-zisa clas a
problemelor uoare.
Limbaje formale
Rezolvarea problemelor de decizie poate profita de instrumentele oferite
de teoria limbajelor formale. Vom recapitula n cele ce urmeaz cteva
concepte ale limbajelor formale. Un alfabet este o mulime finit de
simboluri. Un limbaj L peste este orice mulime de iruri formate din
77
NP-completitdine
simbolurile mulimii . Simbolizm irul vid prin i limbajul vid prin

. Limbajul tututor irurilor peste se noteaz cu *. Orice limbaj peste
este o submulime a lui *.
reuniuneai sau intersecia. Complementul unui limbaj, notat prin > se

Limbajele motenesc operaiile din teoria mulimilor, cum ar fi
definete ca fiind * \ L. Concatenarea a dou limbaje L1 i L2 este

limbajul:
L = {12: 1 L1, 2 L2}
nchiderea sau steaua Kleene a unui limbal L este:
L* = {} L L2 L3 ...
unde Lk este limbajul L obinut prin concatenarea cu el nsui de k ori.
Din punctul de vedere al teoriei limbajelor, o instan a unei probleme P

este un element din *, cu = {0, 1}. Datorit modului de definire al
problemelor de decizie putem considera problema P ca fiind mulimea
instanelor la care problema rspunde afirmativ, deci vom avea:
L = { *| P() = da }
Prin intermediul limbajelor formale putem exprima relaii ntre

problemele de decizie i algoritmii care i rezolv. Spunem c un
algoritm A accept o intrare {0,1}* dac ieirea algoritmului
corespunztoarea intrrii este da, A() = da. Continund, limbajul
acceptat de un algoritm A este mulimea instanelor acceptate de
algoritm:
L = { {0,1}*| A() = da}
Analog, vom considera c un algoritm respinge un ir dac A() = nu.
Un limbaj L este acceptat n timp polinomial de ctre un algoritm A

dac exist o constant k astfel nct pentru orice instan de lungime n
din L, algoritmul l accept n O(nk).
78
NP-completitdine
Exemplu. Considerm un graf G = (N, V). Se cere s se determine dac

exist un drum ntre nodurile u, v N n graful G.
Limbajul corespunztor acestei probleme se poate defini ca:
L = {(G, u, v) | exist un drum ntre nodurile u i v n graf}
Limbajul L poate fi acceptat n timp polinomial de un algoritm care

implementeaz o metod de cutare a drumurilor ntr-un graf i
returneaz da dac a fost gsit un astfel de drum i nu n caz contrar.
Se poate defini drept clas de complexitate mulimea de limbaje pentru

care apartenena unui element este determinat de o msur a
complexitii algoritmului de testare a apartenenei. Astfel, folosind
teoria limbajelor formale, putem da o definiie alternativ a clasei de
complexitate P:
P = {L {0,1}*| exist un algoritm care accept L n timp polinomial}
Verificri n timp polinomial

Vom discuta n cele ce urmeaz despre algoritmi care verific
apartenena la diverse limbaje. Un algoritm de verificare se definete ca
fiind un algoritm cu doi parametrii:
o intrare oarecare,
o intrare prob,
Un algoritm de verificare accept o intrare doar n baza unei probe

A(, ) = 1 i obinem c L este un limbaj verificat de un algoritm de
verificare A dac este mulimea de intrri
L = { {0.1}*| exista proba {0,1}* a.. A(, ) = true}
Obinem c un algoritm A verific un limbaj L dac pentru orice intrare

{0,1}* exist o prob {0,1}* pe care A o poate folosi pentru a
demonstra L.
79
NP-completitdine
Exemplu. Pentru un graf care conine un ciclu hamiltonian, lista

vrfurilor din ciclu este proba necesar pentru a demonstra acestei
proprieti. Dac un graf nu este hamiltonian, nu exist nicio list de
vrfuri n baza creia algoritmul s poat obine c acele vrfuri se afl pe
un ciclu hamiltonian.
Determinism
Numim algoritm determinist o secven finit de instruciuni n care
fiecare operaie are un rezultat unic determinat. Un algoritm determinist
se bucur de asemenea de proprietatea de serialitate: la un moment dat, n
timpul execuiei se execut o singur aciune.
Algoritmii determiniti sunt algoritmii a cror evolutie este unic

determinat n baza instruciunilor pe care le conin. Mai precis, n fiecare
moment al execuiei, instruciunea care urmeaz s fie executat este unic
determinat.
Spre deosebire de acetia, algoritmii nedeterminiti includ operaii al

cror rezultat nu este unic definit ca avnd valori ntr-o mulime finit de
posibiliti. Un algoritm nedeterminist are o structura arborescent de
operaii. Operaiile de pe o cale din arbore sunt efectuate secvenial iar
cele de pe ci diferite sunt efectuate n paralel astfel c la un moment dat
se pot executa mai multe aciuni definite pe ci diferite. Algoritmii
nedeterminiti nu sunt direct aplicabili ns studiul acestora aduce n
discuie concepte foarte importante. Execuia unui algoritm nedeterminist
implic alegeri nedeterministe.
Un algoritm nedeterminist este considerat corect dac exist o posibilitate

de execuie a sa care s determine soluia corect.
Exemplu de algoritm nedeterminist: algoritmul care caut ieirea dintr-

un labirint.
if not iesire(pozitie_curenta)
if not perete(nord(pozitie_curenta)) then
pozitie_curenta nord(pozitie_curenta)
80
NP-completitdine
if not perete(est(pozitie_curenta)) then
pozitie_curenta est(pozitie_curenta)
if not perete(sud(pozitie_curenta)) then
pozitie_curenta sud(pozitie_curenta)
if not perete(vest(pozitie_curenta)) then
pozitie_curenta vest(pozitie_curenta)
endif
endif
Comportamentul acestui algoritm nu se cunoate a-priori (nu se tie

dinainte drumul pe care l va genera algoritmul n labirint). ns acest
algoritm reprezinta dovada c problema se poate rezolva algoritmic. Iar
n virtutea faptului c orice algoritm nedeterminist se poate transforma n
unul determinist, putem obine varianta determinist a problemei n
cauz. Pentru exemplul dat, transformarea ar nseamna generarea tuturor
drumurilor posibile la fiecare pas al executiei.
Operaiile caracteristice algoritmilor nedeterminiti sunt:
- choice(A) : ramific copia curent a algoritmului A n mai

multe copii; copiile continu n paralel i independent una de alta
- fail : copia curent se termin cu eec, restul copiilor (dac mai
exist) continu execuia
- succes : copia curent se termin cu succes, celelalte copii sunt
terminate
Valoarea de return al unui algoritm nedeterminist este succes cnd una

din ci se termin cu succes sau fail cnd toate cile din arborele de
operaii eueaz.
Complexitatea unui algoritm nedeterminist se definete ca suma tuturor

operaiilor din secvena cea mai scurt care determin algoritmul s se
termine cu succes, iar n cazul n care toate cile se termin pe fail,
81
NP-completitdine
complexitatea algoritmului este suma complexitii operaiilor de pe

calea cea mai lung.
Observaie: operaia choice(A) se consider a avea complexitatea

O(1).
Etapele construirii unui algoritm nedeterminist sunt urmtoarele:
- generare, care corespunde instruciunii choice ce are ca scop

generarea de copii pentru fiecare candidat la soluie
- testare, care corespunde instruciunii ce testeaz dac s-a obinut
soluia corect
Observaie: caracteristica nedeterminist este dat de etapa de generare.
Algoritmii de optim pot fi modelai ca apeluri succesive ale unor

algoritmi de decizie. Exemplu: determinarea arborelui de acoperire
minim pentru un arbore fr costuri pe muchii exist un astfel de arbore
de o muchie? dac nu, exist un arbore de acoperire de 2 muchii? etc.
Exemple de algoritmi nedeterminiti
Cautarea unui element intr-un vector

input: v[1...n], elem
caut(v, elem) {
i choice(1..n) // generare
if (v[i]=elem) then return success // testare
else return fail
Testarea daca un numar natural este neprim

input: n
neprim(n) {
i choice(2.. |sqrt(n)|) // generare
82
NP-completitdine
if (n mod i=0) then return success // testare
else return fail
Sortarea unui vector de elemente strict pozitive

input: v[1 ...n]
sort(v, n) {
for i 1, n
aux[i] 0 // in aux vom crea vectorul sortat
for i 1, n
j choice(1..n) // generare
if (aux[j]>0) then return fail // testare
else aux[j] V[i]
for i 1, n-1
if (aux[i]>aux[i+1])then return fail // testare
else return success // daca niciun test nu a
// dat fail, success
Clase de complexitate P i NP
Termenul de NP-complexitate vine de la "timp polinomial
nedeterminist". Aceast clas cuprinde toate problemele de decizie crora
li se poate asocia un set de soluii posibile, fiecare soluie putnd fi
verificat dac este sau nu o soluie potenial ntr-un timp polinomial.
Mai precis, un limbaj L aparine clasei NP dac i numai dac exist un

algoritm A care verific intrrile lui L n timp polinomial:
83
NP-completitdine
L = { {0,1}* | exista proba a.. (A(, ) = da) O(||k)}
pentru k o constant.
Teoria complexitii se ocup cu studiul clasificrii problemelor i al

granielor existente ntre diferitele clase de probleme. Se analizeaz, de
asemenea, resursele de calcul necesare pentru a rezolva o anumit
problem. Problematica central, cea mai cunoscut, a acestei teorii este
ntrebarea:
P = ? NP
Clasa de complexitate P este reprezentat de mulimea tuturor

problemelor de decizie care au complexitate polinomial. De exemplu,
apartenena unui element la un vector are ordinul de complexitate O(n),
unde n reprezinta numarul de elemente al vectorului, deci are
complexitate polinomiala (mai precis, ordinul de complexitate este
linear).
O problem este considerat problem dificil dac complexitatea ei

este exponenial n raport cu dimensiunea instanelor. O problem este
accesibil dac complexitatea ei se poate defini sub forma unui functii
polinomiale, de un grad orict de mare.
Clasa tuturor problemelor care se pot rezolva cu algoritmi nedeterminiti

ntr-un timp polinomial se noteaz cu NP (Nedeterminist Polinomial).
Este evident c orice problem care se afl n P se afl i n NP:
algoritmii determiniti sunt doar un caz extrem al celor nedeterminiti
prin faptul ca n fiecare moment au o singur alegere posibil. ns
transformarea ntr-un algoritm determinist se face de cele mai multe ori
prin pierderea eficienei, genernd algoritmi determiniti care au
complexitate exponenial. Avem deci o incluziune de mulimi ntre
problemele de decizie: P NP EXP.
tim cu certitudine c P EXP, ns nu avem nici o idee despre relaia

dintre clasele NP i P sau dintre clasele NP i EXP. Problema egalitatii
P=NP este cea mai important problem din teoria calculatoarelor, pentru
c soluionarea ei ar avea multe consecine importante.
84
NP-completitdine
n 1971 Cook a demonstrat c exist o problem special n NP (clasa

problemelor pentru care se poate da un algoritm eficient nedeterminist),
numit problema satisfiabilitii (notat cu SAT). Problema este foarte
simpl: dac se d o formul boolean care cuprinde mai multe variabile,
poate fi formula fcut adevrat dnd anumite valori variabilelor? De
pild formula (x1 x2) (x1 x2) devine adevrat pentru x1=true i
x2 {true, false}. SAT este foarte important, pentru c Cook a
demonstrat c dac SAT poate fi rezolvat n P (adic folosind un
algoritm determinist polinomial), atunci orice problem din NP poate fi
rezolvat n timp polinomial! Problema satisfiabilitii booleene este
considerata cea mai grea problem din NP, pentru c rezolvarea
oricrei alte probleme din NP se poate face mai repede'' dect a ei. Din
aceast cauz SAT se mai numete problem NP-complet.
De la Cook ncoace s-au mai descoperit cteva sute de probleme NP-

complete. Unele probleme care se ivesc foarte adesea n practic s-au
dovedit NP-complete. Acesta este un alt motiv pentru care clasa
abstract a problemelor cu algoritmi nedeterminiti este att de
important: foarte multe probleme practice au algoritmi polinomiali
nedeterminiti, dar cei mai buni algoritmi determiniti iau un timp
exponenial!
Iat cteva exemple de probleme NP-complete:
1) Problema comis-voiajorului (turneu Hamiltonian de cost minim):

dndu-se o reea de orae, o reea de drumuri ntre orae i o lungime k,
exist un traseu de cost mai mic dect k trecnd prin fiecare ora o singur
dat i revenind la punctul de plecare?
2) Dndu-se o mulime de numere naturale, se poate mpri aceast

mulime n dou submulimi de numere de sume egale?
Clasa de complexitate P reprezint clasa problemelor care pot fi rezolvate

rapid iar NP reprezint clasa problemelor a cror soluie poate fi
verificat rapid sau clasa de probleme pentru care exist un algoritm
nedeterminist polinomial. Cu alte cuvinte, a verifica o soluie este
echivalent cu a gsi soluia problemei? Rspunsul la aceast ntrebare
85
NP-completitdine
rezolv mai multe probleme majore ale acestei discipline. Cei mai muli
cercettori cred c P i NP nu reprezint aceeai clas dar consider c
NP include clasa P.
Este evident faptul c P NP: dac exist un algoritm A care accept un

limbaj L n timp polinomial atunci acesta poate fi uor transformat ntr-un
algoritm de verificare n timp polinomial (ignor orice prob i accept
doar elementele limbajului L).
Exist un alt argument pentru a demonstra c P NP i acesta este dat de

limbajele NP-complete. Clasa problemelor NP-complete are urmtoarea
proprietate: dac pentru o singur problem NP-complet se poate gsi
un algoritm care s o poat rezolva n timp polinomial, atunci pentru
toate problemele NP-complete se poate gsi un algoritm de rezolvare
polinomial i astfel am putea obine P = NP. Invers, dac o singur
problem se dovedete a fi dificil, atunci ntreaga clasa NP devine
distinct de clasa P.
Figure 4 Modelul acceptat de majoritatea informaticienilor pentru clasele P, NP, NP-complete.
Marea majoritate a informaticienilor consider relaia ntre clasele P, NP

i NP-complete ca n Figura 4: ambele clase de probleme P i NP-
complete sunt incluse n clasa NP iar P NP-complete = .
Limbajele NP-complete sunt considerate cele mai dificile limbaje din

NP. n continuare vom studia dificultatea relativ a acestora folosind o
noiune numit reductabilitate n timp polinomial.
86
NP-completitdine
Reducere polinomial
Reducerea poate fi vzut ca o modalitate de a afirma c o problem este
la fel de uoar sau la fel de grea ca o alt problem. Vom folosi
reducerea pentru a arta dificultatea de rezolvare a unei probleme prin
transformarea ei ntr-o problem deja cunoscut ca fiind o problem grea.
Intuitiv, o problem P poate fi redus la o problem P dac orice

instan a problemei P poate fi reformulat ca o instan a problemei P
iar gsirea unei soluii pentru P va nsemna gsirea unei soluii pentru P.
Algoritm P
Input
Input pentru P Reducere R R(x) Algoritm P Output P
Figure 5 Tehnica de reducere polinomial
Considerm P i Q dou probleme de decizie. Avem c P este reductibil

n Q dac i numai dac exist o funcie R astfel nct:
- R transform o instan x P ntr-o instan R(x) Q

- R este calculat n timp polinomial
- P(x) i Q(R(x)) au aceeai valoare
n urma verificrii acestor condiii obinem ca problema P este reductibil

(n f(n)) n problema Q dac R(x) este calculabil n O(f(n)).
Teorem. Presupunem c P este reductibil n Q, i are complexitatea

f(n).
1) Dac P are complexitatea (g(n)) atunci Q are complexitatea

(g(n)-f(n)).
2) Dac Q are complexitatea O(g(n)) atunci P are complexitatea
O(f(n)+g(n)).
87
NP-completitdine
Problema satisfiabilitii (SAT)

Enun: Se d o formul F din calculul propoziional n forma normal
conjunctiv i n care apar variabile din {x0, ..., xn-1}. Se cere s se
determine o substituie pentru variabilele lui F pentru care F este
satisfcut.
nainte sa descriem algoritmul pentru rezolvarea acestei probleme, vom

prezenta mai nti formalismele logicii propoziionale.
Logica propoziiilor este un caz particular al logicii cu predicate de

ordinul I. La fel ca n cazul logicii propoziiilor, definirea logicii cu
predicate de ordinul I ncepe prin a fixa alfabetul limbajului. Alfabetul
conine simboluri pentru reprezentarea constantelor (notate a, b, ...),
variabilelor (notate X, Y, ...), funciilor (notate cu f, g, ...), predicatelor
(notate cu p, q, ...), a conectorilor i cuantificatorilor logici. Conectorii
logici folosii n logica cu predicate de ordinul I sunt: ~, , , i iar
cunatificatorii sunt: cuantificatorul existenial () i cuantificatorul
universal ().
O formul n logica propoziional sau o expresie Boolean cuprinde
cu ), OR (disjuncie, ), NOT (negaie, ) i paranteze. Implicaia este

variabile, operatori logici sau conective logice: AND (conjuncie, notat
considerat fals numai n cazul n care un antecedent adevarat implic

un consecvent fals (AB sau ~AB). Adevrul sau falsitatea unei
formule rezult din valorile de adevr/fals ale componentelor i din
modul n care operatorii combin componentele n cadrul frazei.
Considerm SF o mulime finit de simboluri funcionale n care fiecare

simbol are ataat un numr natural numit aritatea simbolului respectiv.
Dac f SF este un simbol de aritate n atunci avem f(x1, ..., xn).
Considerm SC o mulime finit de simboluri de constante.
Considerm SP o mulime finit de simboluri de predicate. Ca i n cazul

simbolurilor funcionale, fiecare simbol de predicat are ataat un numr
care reprezint aritatea simbolului.
88
NP-completitdine
Considerm SV o mulime finit de elemente numite variabile.
Un atom peste o baz B este definit ca un element de forma p(t1, ..., tn),
unde p(n) SP i t1, ..., tn sunt termeni peste B.
Se numete literal un atom sau negaia unui atom. Literalul reprezentat

de un atom se numete literal pozitiv iar literalul reprezentat de negaia
unui atom se numete literal negativ.
O formul corect n logica cu predicate de ordinul I se definete astfel:
- 1) un atom este o formul corect

- 2) daca p este o formul corect, atunci: ~p, (x)p(x), (x)p(x)
sunt formule corecte
- 3) daca p i q sunt formule corecte atunci: pq, pq, pq, pq
sunt formule corecte
- 4) orice formul corect este generat prin aplicarea de un numr
finit de ori a regulilor (1)(3)
ntr-o formul variabilele pot fi variabile libere sau legate. O variabil

este legat dac exist un cuantificator care o refer. n caz contrat,
variabila este liber. O formul care conine variabile libere nu poate fi
evaluat.
O formul f se spune c este n forma normal conjunctiv dac se poate

exprima ca o conjuncie de m componente astfel nct fiecare
component s fie o disjuncie de literali.
O formul se numete satisfiabil dac exist o anumit interpretare n

care formula este adevrat. Problema satisfacerii formulei Booleene -
problema SAT are scopul de a determina, pentru o formul dat, dac
aceasta este satisfiabil. Aceast problem de decizie are o mare
importan pentru mai multe domenii ale informaticii, ca de exemplu
informatica teoretic, teoria complexitii, algoritmi i inteligen
artificial.
n cele ce urmeaz considerm o clauz drept o disjuncie de literali.

Obinem c o formul este n form normal conjunctiv dac este o
89
NP-completitdine
conjuncie de clauze. Problema SAT decide dac o formul n forma

normal conjunctiv este satisfcut de o interpretare astfel nct toate
clauzele s fie adevrate.
Definiie. Problema de satisfiabilitate se definete astfel:
Instan: m clauze Ci formate folosind n variabile logice (literali)
Output: Formula F = C1 C2 ... Cm este satisfacut?
De exemplu, formula (x y z) (x y) (x z) este

satisfcut de substituia:
= {(x, true), (y, false)}
Teorm (Steven Cook, 1971) Problema SAT este NP-complet.
Este uor de verificat c problema SAT este n NP. Dac se consider cei
n literali stocai pe n bii de memorie, verificarea satisfiabilitii se reduce
la a verifica dac toate clauzele sunt satisfcute, ceea ce implic o
complexitate polinomial, O(nm).
Algoritmul nedeterminist care rezolv SAT este urmtorul:
1. ghicete o atribuire pentru variabile

2. calculeaz valoarea formulei
3. dac formula este satisfacut ntoarce succes; altfel ntoarce
fail.
Varianta kSAT a problemei de satisfiabilitate este de a gsi o interpretare

variabilelor unui formule date n form normal conjunctiv ale crei
clauze sunt formate din k literali.
Pentru k 3, versiunea kSAT a problemei de decizie este NP-complet,

dar pentru k=2 problema este rezolvabil n timp polinomial, aa cum se
arat n cele ce urmeaz.
90
NP-completitdine
Varianta 2SAT
Se d o formul boolean F n forma normal conjunctiv astfel nct
fiecare clauz conine exact doi literali. S se determine dac exist o
substituie (atribuire de valori) care s satisfac formula F.
Teorem. Problema 2SAT are complexitate polinomial, deci 2SAT

P.
Dndu-se o formul propoziional F n form normal conjunctiv n

care toate clauzele sunt formate din dou literali, trebuie s gsim o
interpretare I variabilelor sale, care satisface F. n acest scop, pornind de
la o formul F - instan de 2SAT, vom defini un grafic G(F), dup cum
urmeaz:
- nodurile lui G sunt date de variabilele formulei F i negaia

acestora;
- G conine un arc orientat de la nodul u la nodul v, (u, v) dac i
numai dac exist o clauz (u v) sau (v u).
A se remarca faptul c o clauz (u v) va genera dou arce n graful G:
- (u, v) dat de (u v)
- (u, v) dat de ((v) u)
Obinem c graful G are o proprietate de simetrie: dac exist un arc (u,

v) n G atunci va exista i arcul (u, v) n G.
Exemplu. S considerm urmtoarea formul: (x1 x2) (x1 x3)

(x1 x2) (x2 x3) . Graficul corespunztor acestei formule este
prezentat n Figura 6.
Intuitiv, arcele reprezint implicaiile logice ale formulei F (n fapt, o

implicaie u v poate fi rescrise ca u v). Prin urmare, drumurile n
graful G(F) sunt implicaii logice ale formulei F.
Scopul problemei 2SAT este s gseasc o interpretare n care formula F

s fie adevrat, adic s gaseasc o substituie pentru variabilele
formulei F astfel nct valoarea lui F s devine true.
91
NP-completitdine
Figure 6 Graful G(F)
Dac adoptm urmtoarea convenie: s colorm cu rou valorile false i

cu verde valorile true din graf, observm c pentru x1 = false, x2 = true i
x3 = false toate arcele grafului sunt pe verde, adic toate implicaiile
formulei F sunt adevrate. Ceea ce se traduce n faptul ca toate clauzele
lui F sunt true, deci conjuncia de clauze este satisfacut.
Figure 7 O interpretare a formulei F (x1=false, x2=true i x3=false)
92
Bibliografie
[1] Irina Athanasiu, Limbaje formale i automate (Note de curs), 2012
[2] Dumitru Dan Burdescu, Analiza complexitii algoritmilor, Editura
Albastra, Cluj Napoca, 1998.
[3] Mihai Budiu, Algoritmi,
http://www.cs.cmu.edu/~mihaib/articole/algoritmi/algoritmi-
html.html, 1997.
[4] Thomas H. Cormen, Charles E. Leiserson, Ronald R. Rivest,
Introducere n algoritmi, Editura Computer Libris Agora, 2000
[5] Cristian Giumale, Analiza algoritmilor (Note de curs), 2014
[6] Mihai Gontineac, Limbaje Formale i Teoria Automatelor, Note de
curs (http://www.math.uaic.ro/~gonti/Didactics.htm)
[7] Dorel Lucanu, Mitic Craus, Proiectarea algoritmilor, Editura
Polirom, 2008
[8] Drgan Mircea, Limbaje Formale i Tehnici de Compilare, 2006
[9] Drgan Mircea, tefan Mruter, Limbaje Formale, 2005
[10] Mihnea Muraru, Paradigme de programare, Note de curs 2012
[11] Daniela Zaharie, Algoritmi Note de curs,
http://web.info.uvt.ro/~dzaharie/alg/alg2014.html, 2014

Curs Metode de Analiza A Algoritmilor

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curs Metode de Analiza A Algoritmilor

Încărcat de

Drepturi de autor:

Formate disponibile

qwertyuiopasdfghjklzxcvbnmq Maina Turing

Calcule realizate de Maina Turing ................................................................. 21

Timpul de execuie .......................................................................................... 31

Ordinul de cretere ......................................................................................... 37

Metoda substituiei ......................................................................................... 58

Problema Turnurilor din Hanoi ....................................................................... 72

Limbaje formale .............................................................................................. 77

Algoritmi i funcii calculabile

Un limbaj al crui scop unic este acela de a descrie algoritmi se numete

Domeniul de date: o mulime numrabil de elemente asupra

Limbajul algoritmic are caracteristica de modularitate, modulele fiind

unde <variabila> este un nume de variabil iar <expresie> este o

unde <conditie> este o expresie care prin evaluare va produce un

Sintaxa instructiunii while

Aceast instruciune implic evaluarea componentei <conditie>.

Sintaxa instructiunii for

for <variabila> <expresie_inf> to <expresie_sup> do

for <variabila> <expresie_sup> downto <expresie_inf> do

pentru care <variabila> este o variabil de tip ntreg iar

Blocul de instruciuni al unei instruciuni for se execut cel puin o dat

Sintaxa intructiunii repeat

unde <conditie> este o expresie care prin evaluare produce un

Acest tip de instruciune asigur execuia cel putin o dat a instruciunilor

Se poate ca, pentru anumite date din mulimea de intrare, problema p s

Rezumnd, un algoritm trebuie s aib urmtoarele proprieti:

Generalitate: un algoritm nu rezolv doar o anumit problem, ci o

Un algoritm trebuie s fie general. Algoritmul trebuie s funcioneze

De exemplu, s considerm problema sortrii cresctoare a unui ir de

Vom considera mai departe o variant de sortare prin metoda bulelor. a

- compar primele dou numere i, dac nu sunt n ordinea dorit,

- la fel procedeaz pentru perechea format din al doilea i al treilea

- algoritmul continu pn ajunge s compare penultimul element

Este aceast variant de sortare un algoritm general? Realizeaz sortarea

Un algoritm trebuie s fie finit. Un algoritm trebuie s se termine, adic

Step3: if x=10 then STOP

Funcioneaz acest algoritm? Ce rezultat va genera?

Un algoritm trebuie s fie neambiguu. Operaiile unui algoritm trebuie

Step 2: Either increment or decrement x with 1

Step 3: if x [-2,2] then GO TO Step 2

Asupra unui algoritm se pun o serie de condiii:

Corectitudine: acest lucru nseamn s se verifice dac algoritmul

Eficien: acest lucru nseamn a stabili cantitatea de resurse (spaiu de

Testarea corectitudinii unui algoritm implic de obicei urmtorii pai:

1) Analiza experimental. Algoritmul se testeaz pe diferite instane ale

2) Analiza formal. Scopul analizei formale este de a dovedi c

Principalul dezavantaj este dificultatea de a gsi o dovad, n special

Principalele etape n analiza formal a corectitudinii unui algoritm sunt:

Identificarea proprietilor de date de intrare (aa numita problem a

Identificarea proprietilor pe care trebuie s le ndeplineasc datele de

Demonstrarea faptului c, ncepnd de la precondiii i prin executarea

Cnd analizm corectitudinea unui algoritm un concept util este cel al

Starea algoritmului este definit prin setul de valori corespunztor

n cazul n care structura de prelucrare este una secvenial atunci

Dificultile pot aprea datorit instruciunilor repetitive, deoarece exist

Exemplu. Algoritmul de sortare prin inserie:

Input: un vector de n elemente v[1...n].

Output: un vector obinut prin sortarea elementelor din v.

Descrierea formal a algoritmului: se pornete cu o list vid de elemente

Algoritmul de sortare prin insertie

S demonstrm corectitudinea algoritmului de sortare prin insertie prin

1. Cazul de baz. Se arat c I(1) este adevrat.

2. Pasul inductiv. S presupunem c I(k) este adevrat pentru k < n. Se

Invariani n structurile repetitive (n englez Loop invariants) sunt