Acest fiier conine o introducere n generalizarea clasificrii problemelor conform unor clase de complexitate diferite de P i NP.

Fiierul conine fragmente revzute i adugite din capitolul 3 din "Introducere n Analiza Algoritmilor".

3.4 O ierarhie spaiu-timp a problemelor

n seciunile precedente, dificultatea rezolvrii problemelor a fost analizat n raport cu timpul consumat de algoritmi. Clasele P i NP sunt definite pe aceast baz. O alt resurs important este spaiul de memorie consumat. Astfel, ierarhizarea P-NP poate fi extins din perspectiva complexitii spaiale impuse de rezolvarea problemelor. Seciunea prezint, intuitiv, o ierarhie posibil spaiu-timp a problemelor i, implicit, relaii ntre complexitatea temporal i cea spaial. Sunt considerate doar probleme de decizie, fr ca generalitatea s fie afectat. n ceea ce privete metrica folosit pentru a msura dimensiunea datelor i consumul de timp i spaiu, se reamintesc urmtoarele convenii: Dimensiunea datelor algoritmilor este un numr ntreg pozitiv. Msura timpului este unitar. Algoritmul efectueaz operaiile considerate elementare (adunri, nmuliri, comparaii etc.) ntr-un numr finit i limitat de uniti de timp, adic n (1). Datele sunt memorate ca iruri de simboluri dintr-un alfabet . n particular, putem alege ={0,1}, fr a afecta generalitatea rezultatelor relativ la posibilitile curente ale mainilor de calcul. Astfel, dac dimensiunea unei date d este cel mult n, sunt necesari (lg(n)) bii pentru a stoca d.

De asemenea, convenim ca spaiul ocupat de datele nemodificate de un algoritm, de obicei datele de intrare, s nu participe n calculul complexitii spaiale a algoritmului. Decizia este justificat dac ne gndim c unul din scopurile analizei complexitii este clasificarea problemelor n raport cu resursele consumate. Ar fi nepotrivit s considerm c rezolvarea unei probleme Q1 este mai dificil dect cea a unei alte probleme Q2 doar pentru c dimensiunea datelor lui Q1 este mai mare dect dimensiunea datelor lui Q2. Din alt punct de vedere, astfel de date read-only pot fi stocate n "afara" algoritmului.

Cristian Giumale, Note de curs

3.4.1 Clase de probleme rezolvate determinist

Fie Q:I{0,1} o problem de decizie, rezolvabil prin mulimea algoritmilor determiniti AlgQ, i f:R+ o funcie total peste (numit funcie de limitare). Notm:
Alg Q (f)= {AlgAlgQ | iI timp(Alg,i)=(f(n))} Alg Q (f)= {AlgAlgQ | iI spaiu(Alg,i)=(f(n))},
S T

unde n=dim(i) este dimensiunea datelor i, timp(Alg,i) este timpul consumat de calculul serial Alg(i), iar spaiu(Alg,i) este spaiul maxim de lucru consumat n cursul execuiei Alg(i). Mai precis, s notm:
stri(Alg,i) strile din secvena execuiei Alg(i). Fiecare stare este asociat cu un moment de timp t al execuiei i desemneaz mulimea variabilelor existente la momentul t al execuiei precum i instruciunea curent executat. spaiu_stare(s) spaiul consumat de variabilele din starea s, excluznd datele nemodificabile ale algoritmului.

Deci, pentru un algoritm serial, spaiu(Alg,i) = max{sstri(Alg,i)

spaiu_stare(s)}.

Mulimea Alg Q (f) conine acei algoritmi determiniti care rezolv problema Q n
(f(n)) uniti de timp, iar Alg Q (f) conine acei algoritmi determiniti care rezolv
S

problema Q folosind (f(n)) uniti de spaiu de lucru. Definiia 3.26 Fie f:R+ o funcie total peste . Clasele de probleme rezolvabile prin algoritmi determiniti, cu limitare f, temporal i, respectiv, spaial sunt:
TIME(f) =def {Q | Alg Q (f) } SPACE(f)=def {Q | Alg Q (f) }
S T

n particular,
P = PTIME =def PSPACE =def
k 0

( n.nk) ! TIME

k 0

SPACE (n.nk )

LOGSPACE =def SPACE(n.lg(n)),

unde n.R(n) desemneaz o funcie cu parametrul n i rezultatul R(n).

Clase de probleme

Ca exemplu, s clasificm problema GAP (Problema Accesibilitii ntr-un Graf). Pentru un graf G cu n noduri s se decid existena unui drum ntre dou noduri date, i i j, din G. Propoziia 3.11 GAPSPACE(lg(n)2) i GAPTIME(n2) (sau GAPPTIME). 1. GAPSPACE(lg(n)2). S construim un algoritm care rezolv problema ntrun spaiu de lucru (lg(n)2)
GAP_S(G,i,j) { // G are nodurile V(G) i arcele E(G). // Exist drum i..j n G? n = card(V(G)); for(lung=0; lung < n; lung++) if(drum(i,j,lung)) return 1; // G i n sunt vizibile n funcia drum return 0; } drum(i,j,lung){ if(lung = 0) return i=j ? 1 : 0; if(lung = 1) return (i,j)E(G); l1= lung/2; l2= lung/2; for(k = 1; k n; k++) if(drum(i,k,l1) drum(k,j,l2))) return 1; return 0; }

Algoritmul drum ncearc s formeze drumul i..j din drumurile i..k i k..j, pe jumtate mai scurte ca numr de arce dect drumul i..j. Procesul este repetat pn ce lungimea unui drum devine 0 sau 1. Corectitudinea algoritmului deriv din urmtoarea observaie: un drum x..y de lungime l exist dac i numai dac este satisfcut una din condiiile:
l = 0 i x = y; l = 1 i (x,y) este un arc al grafului; l >1 i exist drumurile x..z de lungime l/2 i z..y de lungime l/2 .

Spaiul consumat de algoritmul drum este (lg(n)2). ntr-adevr, lungimea maxim a lanului de apelurilor recursive este limitat la lg(n), iar fiecare apel consum spaiu pentru 6 variabile i spaiu pentru nregistrarea de activare a apelului. Deoarece se lucreaz cu ntregi de valoare cel mult n, spaiul consumat la apelul k este k (lg(n)) bii, astfel nct la apelul lg(n) se consum (lg(n))2 bii. n partea GAP_S a algoritmului, datele G, i i j nu contribuie la complexitatea spaial, fiind read-only. Se adaug doar spaiul consumat de variabilele n i lung i de apelul drum(i,j,n), anume (lg(n)) bii. Spaiul folosit de ntregul algoritm este (lg(n)+lg(n)2) = (lg(n)2). Deci GAP SPACE(lg(n)2).

Cristian Giumale, Note de curs 2. GAPTIME(n2). S construim un algoritm care rezolv GAP n timp (n2).

Estimarea timpului cheltuit de algoritmul GAP_S folosete recurena T(l)2n T(l/2)+(n) pentru calculul timpului consumat de apelul drum(i,j,l), considernd c operaia (i,j)E(G) este n (1). Soluia recurenei este (l nlg(l)), astfel nct timpul consumat de GAP_S este (nlg(n)+2). Problema poate fi ns rezolvat mai rapid, parcurgnd graful n adncime.
GAP_T(G,i,j){ // G are nodurile V(G) i arcele E(G). // Exist drum i..j n G? for-each(uV(G)) stare(u)=nevizitat; explorare(i); return stare(j)=vizitat ? 1 : 0; } explorare(u){ stare(u)=vizitat; for-each((u,v)E(G)) if(stare(v)=nevizitat) explorare(v); }

Algoritmul GAP_T parcurge graful n adncime, ncepnd din nodul i. Nodurile vizitate sunt marcate, evitndu-se ciclurile. Rezultatul este decis de marca nodului j. Lanul apelurilor recursive ale algoritmului explorare este (n), iar fiecare apel consum un spaiu de memorie (lg(n)). Spaiul total consumat de algoritm este (n lg(n)), mai mare dect cel al algoritmului GAP_S. n schimb, timpul consumat este (n2). Deci GAPTIME(n2) i, totodat, GAPPIME. !

3.4.2 Clase de probleme rezolvate nedeterminist

Fie N_Alg un algoritm nedeterminist de decizie cu m instruciuni. Numim spaiul de stare al algoritmului pentru datele iI, un graf orientat G(i)=(V,E,s0,sf), unde nodurile V reprezint stri ale algoritmului, iar arcele E desemneaz tranziii ntre stri. O stare este asociat unui moment t al execuiei algoritmului i corespunde valorilor variabilelor algoritmului inclusiv cele anonime, aa cum sunt cele ce desemneaz eventualele nregistrri de activare ale algoritmului la momentul t, precum i instruciunii executate de algoritm la momentul t. O tranziie din starea u n starea v este guvernat de instruciunea executat n starea u. Nodul rdcin s0 corespunde strii iniiale a execuiei algoritmului, iar nodul destinaie sf desemneaz starea corespunztoare terminrii cu succes a algoritmului. Starea sf colecteaz arcele de la toate nodurile success {st1,st2,...,str} ale execuiei N_Alg(i). Notm:
ci(N_Alg,i) mulimea drumurilor simple s0..sf din G(i).

Clase de probleme

stri(d) strile (nodurile) de pe o cale dci(N_Alg,i). Fiecare stare s din stri(d) este asociat unui moment de timp t al execuiei seriale a cii d i desemneaz mulimea variabilelor existente la momentul t al acestei execuii

precum i instruciunea curent executat.

timp_cale(d) timpul total necesar execuiei seriale a tuturor prelucrrilor din calea d (a tranziiilor ntre strile din stri(d)). Prin convenie, timpul tranziiei (sti,sf), i=1,r, este 0. spaiu_stare(s) spaiul consumat de variabilele corespunztoare strii s, excluznd datele nemodificabile ale algoritmului. Prin convenie, spaiu_ stare(sf)=0.

Definiia 3.27 Fie Alg un algoritm nedeterminist. Timpul i, respectiv, spaiul consumate de algoritmul Alg pentru datele i astfel nct Q(i)=1 (problema are soluie, iar ci(N_Alg,i)) sunt:
N_timp(N_Alg,i) = min {d ci(N_Alg,i) timp_cale(d)}, N_spaiu(N_Alg,i) = min {d ci(N_Alg,i) spaiu_cale(d)} spaiu_cale(d) = max {sstri(d) spaiu_stare(s)}

Se remarc perspectiva angelic a msurrii resurselor consumate de algoritm pentru datele i: timpul celei mai rapide ci s0..sti,sf, i=1,r, din G(i) i spaiul minim dintre cele maxime consumate de cile s0.. sti,sf, dei spaiul total poate fi mult mai mare. Timpul i spaiul angelic se sprijin pe interpretarea execuiei unui algoritm nedeterminist conform creia algoritmul ghicete calea cea mai rapid sau cu consum minim de spaiu ctre soluie. Msura angelic a timpului i spaiului consumate de un algoritm nedeterminist este suficient pentru a caracteriza performana algoritmului n orice situaie. ntradevr, dac timpul i spaiul rezolvrii n cazul Q(i)=1 este limitat de o funcie f(n), n=dim(i), astfel nct N_timp(N_Alg,i)k f(n) i N_spaiu(N_Alg,i)k' f(n), k i k' constante, atunci orice depire a timpului k f(n) sau a spaiului k' f(n) poate opri execuia Alg(i), rezultatul fiind 0 n mod sigur, ca n figura 3.14.
Depire timp angelic, oprire cu rezultat 0.

sti s0

str

N_timp(N_alg,i)

Figura 3.14 Spaiul strilor execuiei N_Alg(i) pentru rezultat 0

Cristian Giumale, Note de curs

Ca i n cazul algoritmilor determiniti putem s definim clase de algoritmi cu complexitate impus. Fie Q:I{0,1} o problem de decizie, rezolvabil prin mulimea algoritmilor nedeterminiti N_AlgQ, i f:R+ o funcie total peste . Notm:
N_ Alg Q (f)= {AlgN_AlgQ,iI | Q(i)=1 N_timp(Alg,i)=(f(n))}, N_ Alg Q (f)= {AlgN_AlgQ,iI | Q(i)=1 N_spaiu(Alg,i)=(f(n))},
S T

unde n=dim(i) este dimensiunea datelor i. Mulimea N_ Alg Q (f) conine acei algoritmi nedeterminiti care rezolv problema Q n (f(n)) uniti de timp, iar
N_ Alg Q (f) conine acei algoritmi nedeterminiti care rezolv problema Q folosind (f(n)) uniti de spaiu de memorie.
S

Definiia 3.28 Fie f:R+ o funcie total peste . Clasele de probleme rezolvabile prin algoritmi nedeterminiti cu limitare f, temporal i, respectiv, spaial sunt:
NTIME(f) =def {Q | N_ Alg Q (f) } NSPACE(f)=def {Q | N_ Alg Q (f) }
S T

n particular,
NP = NPTIME =def NPSPACE =def
k 0

(n.nk ) ! NTIME

k 0

(n.nk ) ! NSPACE

NLOGSPACE =def NSPACE(n.lg(n)),

unde n.R(n) desemneaz o funcie cu parametrul n i rezultatul R(n). Ca exemplu, s reconsiderm problema GAP, dar rezolvat folosind un algoritm nedeterminist. Propoziia 3.12 GAP NLOGSPACE i GAP NPTIME. Construim algoritmul nedeterminist N_GAP de mai jos i artm c are complexitate spaial (lg(n)) i complexitate temporal (n).
N_GAP(G,i,j) { // G are nodurile V(G) i arcele E(G). // Exist drum i..j n G? n = card(V(G)); u = i; lung = 0; while(u j) { v = choice(V(G)); lung++; // lungime drum (numr arce) if((u,v)E(G) lung n) fail; u = v; } success; }

Clase de probleme

1. GAPNLOGSPACE. Fiecare stare a algoritmului conine doar patru variabile, anume n, lung, u i v, care contribuie la consumul de spaiu al algoritmului (variabilele G, i i j sunt read-only). ntr-adevr, prin efectul instruciunii choice, sunt construite noi copii ale algoritmului, incluznd variabilele folosite. Astfel, pot exista mai multe copii ale algoritmului funcionnd simultan, dar fiecare copie conine doar patru variabile care consum spaiu. Pentru c numerele cu care se lucreaz au valoare cel mult n, spaiul de memorie folosit este (lg(n)). 2. GAPNPTIME. Pentru c un drum n spaiul strilor algoritmului corespunde unui drum n graful G, iar lungimea drumurilor explorate n G este limitat la n, algoritmul se oprete n (n). Cu importan marginal, putem observa c N_GAP se termin imediat ce drumul cel mai scurt i..j din G este gsit. Un astfel de drum nu poate conine cicluri, deci este drum simplu. !

3.4.3 Relaii ntre clase de probleme

Evitm relaiile banale de tipul f(n)=(g(n))TIME(f)TIME(g) i discutm despre relaii ntre clase cu natur diferit, anume relaii timp-spaiu i relaii determinism-nedeterminism. Teorema 3.12
TIME(f) NTIME(f) SPACE(f) NSPACE(f)

Un algoritm determinist, fie el Alg, poate fi considerat nedeterminist, avnd o singur cale n spaiul strilor. Deci dac Alg are complexitate (f(n)) nseamn c, implicit, exist un algoritm nedeterminist cu aceeai complexitate. Prin urmare,
Alg Q (f)N_ Alg Q (f) i Alg Q (f)N_ Alg Q (f) pentru orice problem Q. !
T T S S

Corolarul 3.3

LOGSPACE NLOGSPACE PTIME NPTIME (sau P NP) PSPACE NPSPACE

Incluziunile deriv din definiiile (3.26), (3.28) i din teorema (3.12). ! Se demonstreaz c:
LOGSPACE NLOGSPACE PTIME NPTIME PSPACE = NPSPACE.

De asemenea, se poate generaliza conceptul de completitudine i duritate pentru diversele clase de complexitate. Aceste probleme depesc obiectivul cursului.