Acest fiier conine o introducere n generalizarea clasificrii problemelor conform

unor clase de complexitate diferite de P i NP. Fiierul conine fragmente revzute 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 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 pe care o privim ca limit a complexitii
algoritmilor. Notm:
T

Alg Q (f)= {AlgAlgQ | iI timp(Alg,i)=(f(n))}

S

Alg Q (f)= {AlgAlgQ | iI spaiu(Alg,i)=(f(n))},

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

variabilele care desemneaz date nemodificabile ale algoritmului.

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

spaiu_stare(s)}.
T

Mulimea Alg Q (f) conine acei algoritmi determiniti care rezolv problema Q
S

n (f(n)) uniti de timp, iar Alg Q (f) conine acei algoritmi determiniti care
rezolv 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:
T

TIME(f) =def {Q | Alg Q (f) }

S

SPACE(f)=def {Q | Alg Q (f) }

n particular,
P = PTIME =def
PSPACE =def

U TIME(n.nk)

k 0

U SPACE(n.nk)

k 0

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

unde notaia 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. 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 nodurile success {st1,st2,...,str} ale fiecrei
ci corespunztoare execuiei N_Alg(i). Aceste noduri corespund situaiei celei mai
defavorabile pentru fiecare asemenea cale. Notm:

Clase de probleme

ci(N_Alg,i) mulimea drumurilor simple s0..sf din G(i).

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, n particular, datele de
intrare i. Prin convenie, spaiu_ stare(sf)=0.

Definiia 3.27 Fie N_Alg un algoritm nedeterminist care rezolv o problem de

decizie Q:I{0,1}. Timpul i spaiul de memorie consumate de algoritm pentru
datele iI 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)}, unde

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..sf din G(i) i spaiul minim dintre
cele maxime consumate de cile s0..sf, dei spaiul total poate fi mult mai mare.
Timpul i spaiul angelic se sprijin pe interpretarea: algoritmul ghicete calea cea
mai rapid sau cu consum minim de spaiu ctre soluie.
S notm N_timp(Alg,n) i N_spaiu(Alg,n), complexitatile angelice ale
algoritmului Alg din punctul de vedere al timpului i spaiului consumat n raport cu
dimensiunea n a datelor algoritmului. Spunem c Alg are complexitatea angelic
temporal/spaial limitat n raport cu o funcie f:R+ i scriem N_timp(Alg,n)=
(f(n)), respectiv N_spaiu(Alg,n)= (f(n)), dac:
iI | Q(i)=1 dim(i)=n N_timp(Alg,i)= (f(n))
iI | Q(i)=1 dim(i)=n N_spaiu(Alg,i)= (f(n))

Msurile angelice N_timp(Alg,n) i N_spaiu(Alg,n) ale timpului i spaiului

consumate de un algoritm nedeterminist sunt suficiente pentru a caracteriza
performana algoritmului n orice situaie. ntr-adevr, dac pentru orice date i, astfel
nct Q(i)=1 i dim(i)=n, timpul sau spaiul rezolvrii este limitat n raport cu f(n),
deci N_timp(N_Alg,i)k f(n), nn0, sau N_spaiu(N_Alg,i)k' f(n), n n'0 ,
unde n0, n'0 , k i k' sunt constante, atunci depirea timpului k f(n) sau spaiului k'
f(n) oprete execuia algoritmului pentru orice date cu dimensiunea n, rezultatul
algoritmului fiind 0, aa cum se sugereaz n figura 3.14.

Cristian Giumale/Note de curs

sti

Depire timp angelic,

oprire cu rezultat 0.

s0
str

N_timp(N_alg,i)

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

Ca i n cazul algoritmilor determiniti putem s definim clase de algoritmi
nedeterminiti 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:
T

N_ Alg Q (f)= {AlgN_AlgQ | N_timp(Alg,n) = (f(n))},

S

N_ Alg Q (f)= {AlgN_AlgQ | N_spaiu(Alg,n) = (f(n))},

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
S

N_ Alg Q (f) conine acei algoritmi nedeterminiti care rezolv problema Q folosind
(f(n)) uniti de spaiu de memorie (bii).

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:
T

NTIME(f) =def {Q | N_ Alg Q (f) }

S

NSPACE(f)=def {Q | N_ Alg Q (f) }

n particular,
NP = NPTIME =def
NPSPACE =def

U NTIME(n.nk)

k 0

U NSPACE(n.nk)

k 0

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, a accesibilitii ntr-un graf, de data aceasta rezolvat
folosind un algoritm nedeterminist.

Clase de probleme

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

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 cel mult 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,
T
T
S
S
Alg Q (f)N_ Alg Q (f) i Alg Q (f)N_ Alg Q (f) pentru orice problem Q.

Cristian Giumale/Note de curs

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 obiectivele
cursului.