Compl Medie PDF

Proiectarea algoritmilor: complexitatea medie
Dorel Lucanu
Faculty of Computer Science

Alexandru Ioan Cuza University, Iaşi, Romania
dlucanu@info.uaic.ro
PA 2014/2015
D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 1 / 44

Outline
1 Timpul mediu: algoritmi determinişti

Quicksort determinist
2 Timpul mediu: algoritmi probabilişti

Agoritmi nedeterminişti
Algoritmi probabilişti
Quicksort probabilist
3 k-mediana

Timpul mediu: algoritmi determinişti
Plan


3 k-mediana

Motivaţie
Fie P o problemă, p ∈ P instanţă a problemei P, A un algoritm care

rezolvă P.
Reamintim formula pentru complexitatea ı̂n cazul cel mai nefavorabil:

TA (n) = sup{TA (p) | p ∈ P ∧ g (p) = n}
Uneori, numărul instanţelor p cu g (p) = n pentru care TA (p) = TA (n) sau

TA (p) are o valoare foarte apropiată de TA (n) este foarte mic.
Pentru aceste cazuri este preferabil să calculăm comportarea ı̂n medie a
algoritmului.

Exemplu de variabilă aleatorie: aruncarea a două zaruri
Experiment: aruncarea a două zaruri

V (experiment) = suma punctelor de pe feţele superioare
Sursa: http://hyperphysics.phy-astr.gsu.edu/hbase/math/dice.html
pi = P(V = xi ) - probabilitatea cu P
care V ia valoare xi
Media variabilei aleatorii: M(V ) = i xi · pi

Exemplu de variabilă aleatorie: aruncarea a două zaruri

(cont.)
M(V ) = 7

Definiţie
Pentru a putea calcula comportarea ı̂n medie este necesar să privim
mărimea TA (p) ca fiind o variabilă aleatorie:
o experienţă = execuţia algoritmului pentru o instanţă p,
valoarea experienţei = durata execuţiei algoritmului pentru instanţa
p) şi să precizăm legea de repartiţie a acestei variabile aleatorie.
Apoi, comportarea ı̂n medie se calculează ca fiind media acestei variabile
aleatoare (considerăm numai cazul timpului de execuţie):
TAmed (n) = M({TA (p) | p ∈ P ∧ g (p) = n})
Dacă mulţimea valorilor variabilei aleatoare TA (p) = {x0 , x1 , . . . } este
finită sau numărabilă şi probabilitatea ca TA (p) = xi este pi , atunci media
variabilei aleatorie TA (timpul mediu de execuţie) este:
X
TAmed (n) = xi · pi
i

Exemplu
Considerăm problema căutării unui element ı̂ntr-o secvenţă de numere

ı̂ntregi:
Problema P1
Intrare: n, a = (a
(0 , . . . , an−1 ), z, toate numere ı̂ntregi.
min{i | ai = z} dacă {i | ai = z} = 6 ∅,
Ieşire: poz =
−1 altfel.
Presupunem că secvenţa (a0 , . . . , an−1 ) este memorată ı̂n tabloul a.

Considerăm ca dimensiune a problemei P1 numărul n al elementelor din
secvenţa ı̂n care se caută.

Algoritm pentru P1
Algoritmul A1 descris de următorul program rezolvă P1 :
//@input: un tablou a cu n elemente, z

//@output: pozitia primului element din a egal cu z,
// -1 daca nu exista un astfel de element
i = 0;
while (a[i] != z) && (i < n-1) {
i = i+1
if (a[i] = z) poz = i;
else poz = -1;

Timpul mediu pentru A1

Mulţimea valorilor variabilei aleatorii TA1 (p) este {3i + 2 | 1 ≤ i ≤ n} (s-au
numărat doar atribuirile şi comparaţiile).
În continuare trebuie să stabilim legea de repartiţie. Facem următoarele
presupuneri:
probabibilitatea ca z ∈ {a0 , . . . , an−1 } este q şi
q
probabilitatea ca z să apară prima dată pe poziţia i − 1 este (indicii i
n
candidează cu aceeaşi probabilitate pentru prima apariţie a lui z).
Rezultă că probabilitatea ca z 6∈ {a0 , . . . , an−1 } este 1 − q. Acum probabilitatea
q
ca TA (p) = 3i + 2 (poz = i − 1) este , pentru 1 ≤ i < n, iar probabilitatea ca
n
q
TA (p) = 3n + 2 este pn = + (1 − q).
n
Timpul mediu de execuţie este:
n q n−1 q
TAmed (n)
P P
= pi xi = · (3i + 2) + ( + (1 − q)) · (3n + 2)
i=1 i=1 n n
3nq 3q
= 3n − + +2
2 2
D. Lucanu (FII - UAIC) Complexitatea medie med 3n 7
PA 2014/2015 10 / 44
Timpul mediu: algoritmi determinişti Quicksort determinist
Plan


3 k-mediana

Quicksort: descriere
Este proiectat pe paradigma divide-et-impera.
Se consideră o mulţime peste care este definită o relaţie de ordine liniară
<.
Algoritmul Quicksort
Intrare: S = {a0 , . . . , an−1 }
Ieşire: o secvenţă cu elementele ai ı̂n ordine crescătoare
1 Generalizare (abstractizare): S = {ap , . . . , aq }, p ≤ q.
2 Divizarea problemei constă ı̂n alegerea unei valori x din S. Elementul
x este numit pivot. În general se alege pivotul x = ap , dar nu este
obligatoriu.
3 calculează
S< = {ai | ai < x} S= = {ai | ai = x} S> = {ai | ai > x}
4 sortează recursiv S< şi S>
5 ı̂ntoarce secvenţa S< , S= , S>
Quicksort: partiţionarea
Presupunem că S este memorată ı̂ntr-un tablou a.
Se determinarea prin interschimbări a unui indice k cu proprietăţile:
p ≤ k ≤ q şi a[k] = x;
∀i : p ≤ i ≤ k =⇒ a[i] ≤ a[k];
∀j : k < j ≤ q =⇒ a[k] ≤ a[j];
Partiţionarea tabloului se face prin interschimbări care menţin invariante
proprietăţi asemănătoare cu cele de mai sus. Se consideră două variabile
index: i cu care se parcurge tabloul de la stânga la dreapta şi j cu care se
parcurge tabloul de la dreapta la stânga. Iniţial se ia i = p + 1 şi j = q.
Proprietăţile menţinute invariante ı̂n timpul procesului de partiţionare sunt:
∀i 0 : p ≤ i 0 < i =⇒ a[i 0 ] ≤ x (1)
şi
∀j 0 : j < j 0 ≤ q =⇒ a[j 0 ] ≥ x (2)
Quicksort: partiţionarea
Presupunem că la momentul curent sunt interogate elementele a[i] şi a[j]
cu i < j. Distingem următoarele cazuri:
1 a[i] ≤ x. Transformarea i = i+1 păstrează (1).
2 a[j] ≥ x. Transformarea j = j-1 păstrează (2).
3 a[i] > x > a[j]. Dacă se realizează interschimbarea a[i] ↔ a[j] şi se
face i = i+1 şi j = j-1, atunci ambele predicate (1) şi (2) sunt
păstrate.
Operaţiile de mai sus sunt repetate până când i devine mai mare decât j.
Considerând k = i − 1 şi interschimbând a[p] cu a[k] obţinem
partiţionarea dorită a tabloului.

Quicksort: algoritmul de partiţionare

@input: a = (a[p], . . . , a[q])
@output: k, a cu proprietatea ∀ i : p ≤ i ≤ k =⇒ a[i] ≤ a[k] şi ∀ j :
k < j ≤ q =⇒ a[k] ≤ a[j]
partitioneaza(a, p, q, k) {
x = a[p] ;
i = p + 1; j = q;
while (i ≤ j) {
if (a[i] ≤ x) i = i+1;
if (a[j] ≥ x) j = j-1;
if ((i < j) && (a[i] > x) && (x > a[j])) {
swap(a, i, j);
i = i+1;
j = j-1;
}
}
k = i-1; a[p] = a[k]; a[k] = x;
}

Quicksort: algoritm
După sortarea recursivă a subtablourilor a[p..k − 1] şi a[k + 1..q] se

observă că tabloul este sortat deja. Astfel partea de asamblare a soluţiilor
este vidă.
@input: a = (a[p], . . . , a[q])

@output: elementele secvenţei a ı̂n ordine crescătoare
qsort(a, p, q) {
if (p < q) {
partitioneaza(a, p, q, k)
qSort(a, p, k)
qSort(a, k+1, q)
}
}

Quicksort: timpul ı̂n cazul cel mai nefavorabil
Cazul cel mai nefavorabil se obţine atunci când la fiecare partiţionare se

obţine una din subprobleme cu dimensiunea 1.
Deoarece operaţia de partiţionare necesită O(q − p) comparaţii, rezultă că
pentru acest caz numărul de comparaţii este O(n2 ).
Acest rezultat este oarecum surprinzător, având ı̂n vedere că numele
metodei este “sortare rapidă”.
Aşa cum vom vedea, ı̂ntr-o distribuţie normală cazurile pentru care
QuickSort execută n2 comparaţii sunt rare, fapt care conduce la o
complexitate medie foarte bună a algoritmului.

Quicksort: timpul mediu

Presupunem că q + 1 − p = n (lungimea secvenţei) şi că probabilitatea ca pivotul
1
x sa fie al k-lea element este (fiecare element al tabloului poate fi pivot cu
n
1
aceeaşi probabilitate ). Rezultă că probabilitatea obţinerii subproblemelor de
n
1
dimensiuni k − p = i − 1 şi q − k = n − i este . În procesul de partiţionare, un
n
element al tabloului (pivotul) este comparat cu toate celelalte, astfel că sunt
necesare n − 1 comparaţii. Acum numărul mediu de comparaţii se calculează prin
formula:
n
(n − 1) + 1 P (T med (i − 1) + T med (n − i)) , dacă n ≥ 1

med n i=1
T (n) =
1 , dacă n = 0

Teoremă
Complexitatea medie a algoritmului QuickSort este O(n log2 n).

Timpul mediu: algoritmi probabilişti
Plan


3 k-mediana

Timpul mediu: algoritmi probabilişti Agoritmi nedeterminişti
Plan


3 k-mediana

Definiţie
Activitatea unui algoritm nedeterminist se desfăşoară ı̂n două etape: ı̂ntr-o primă
etapă “se ghiceşte” o anumită structură S şi ı̂n etapa a doua se verifică dacă S
satisface o condiţia de rezolvare a problemei. Putem adăuga “puteri magice de
ghicire” unui limbaj de programare adăugându-i o funcţie de forma:
random(N) – care ı̂ntoarce un număr aleatoriu din mulţimea
{0, 1, . . . , n − 1}.
Pentru a şti dacă verificarea s-a terminat cu succes sau nu adăugă şi două
instrucţiuni de terminare:
success – care semnalează terminarea verificării (şi a a algoritmului) cu
succes, şi
failure – care semnalează terminarea verificării (şi a a algoritmului) fără
succes.
Această definiţie a algoritmilor nedeterminişti este strâns legată de rezolvarea
problemelor de decizie. Reamintim că, ı̂n general, orice problemă poate fi redusă
la rezolvarea unei probleme de decizie.
Funcţia random ı̂n Alk
Următorul exemplu este un generator de numere pseudo-aleatorii din

cartea ”The C Programming Language” de Kernighan and Ritchie.
rand() {
random_seed = random_seed * 1103515245 +12345;
return (random_seed / 65536) % 32768;
}
În Alk este implementată varianta care ı̂ntoarce valoarea calculată modulo
n, unde n este parametrul funcţiei.

Agoritmi nedeterminişti: exemplu
exp() {
return (1 - x[0])*x[1] + x[0]*(1 - x[2]);
}
x[0] = random(2);
x[1] = random(2);
x[2] = random(2);
if (exp() == 1) success;
else failure;

Agoritmi nedeterminişti: demo
$ krun programs/ex1.alk -cST="x |-> { .Map }" -cSEED="1214"

<k>
failure ;
</k>
<state>
x |-> { 0 |-> 0 1 |-> 0 2 |-> 0 }
</state>
$ krun programs/ex1.alk -cST="x |-> { .Map }" -cSEED="1212"
<k>
success ;
</k>
<state>
x |-> { 0 |-> 0 1 |-> 1 2 |-> 1 }
</state>
$

Timpul mediu: algoritmi probabilişti Algoritmi probabilişti
Plan


3 k-mediana

Definiţii
Exista două puncte de vedere:
1. algoritmul probabilist este văzut ca un algoritm nedeterminist
pentru care există o distribuţie de probabilitate peste alegerile
nedetermiste
2. algoritmul probabilist este un algoritm care are o intrare
suplimentară ce constă ı̂ntr-o secvenţă de biţi aleatorii;
e echivalent cu a spune ca algoritmul probabilist constă ı̂n o mulţime
de algoritmi determinisşti din care un algoritm este ales aleatoriu
pentru o intrare dată
pentru o intrare x a problemei date, calculele algoritmului probabilist
pot diferi ı̂n funcţie de e secventa
¸ actuală de biţi aleatori
Această diferenţă poate fi proiectată ı̂n complexitate sau ieşire:
timpul de execuţie văzut ca o variabilă aleatorie
ieşirea văzută ca o variabilă aleatorie
La acest curs consideră doar prima variantă (numiţi şi algoritmi Las
Vegas).
Timpul mediu de execuţie al algoritmilor probabilişti
ProbA,x (C ) = probabilitatea cu care algoritmul A execută calculul C

pentru intrarea x
Time(C ) = timpul necesar lui A ca să execute C
y ieşirea pentru intrarea x
AC (x) ieşirea calculată de C pentru intrarea x
timpul mediu de execuţie aP
lui A pentru intrarea x este
Exp-TimeA (x) = M[Time] = C ,AC (x)=y ProbA,x (C ) · Time(C ).
Time este variabilă aleatorie.
timpul mediu de execuţie a lui A ı̂n cazul cel mai nefavorabil este
Exp-TimeA (n) = max{Exp-TimeA (x) | g (x) = n}

Timpul mediu: algoritmi probabilişti Quicksort probabilist
Plan


3 k-mediana

”Randomized Quicksort”
- exemplul canonic pentru algoritmii Las Vegas
Algoritmul RQS
Intrare: S = {a0 , . . . , an−1 }
Ieşire: elementele ai ı̂n ordine crescătoare
1 dacă n = 1 ı̂ntoarce a0 ,
2 altfel alege aleatoriu uniform k ∈ {0, . . . , n − 1}
3 calculează
S< = {ai | ai < ak }
S= = {ai | ai = ak }
S> = {ai | ai > ak }
4 sortează recursiv S< şi S>
5 ı̂ntoarce secvenţa S< , S= , S>

Analiza algoritmului RQS
Fie funcţia rank astfel ı̂ncât arank(0) ≤ . . . ≤ arank(n−1) .

(
1 arank(i) şi arank(j) sunt comparate
Definim Xij =
0 altfel
Cu ajutorul lui Xij se numără comparaţiile dintre arank(i) şi arank(j) .
Xij este variabilă aleatorie
Numărul mediu de comparaţii este
M[ n−1
P P Pn−1 P
i=0 j>i Xij ] = i=0 j>i M[Xij ].


pij probabiltatea ca arank(i) şi arank(j) să fie comparate ı̂ntr-o execuţie
M[Xij ] = pij × 1 + (1 − pij ) × 0 = pij
2
pij = (probabilitatea ca arank(i) sau arank(j) să fie ales pivot)
j −i +1
n−1 X n−1 X
X X 2
pij =
j −i +1
i=0 j>i i=0 j>i
n−1 X
n
X 2
≤
k
i=0 k=1
n Xn
X 1
=2
k
i=1 k=1
n
X 1
= 2n
k
k=1

Teoremă
Numărul mediu de comparaţii ı̂ntr-o execuţie al algoritmului RQS este cel
mult 2nHn = O(n log n).

k-mediana
Plan


3 k-mediana

k-mediana
k-mediana: definiţie
Definiţie
Fie S o listă cu n elemente dintr-o mulţime univers total ordonată.
k-mediana este cel de-al k-lea element din lista sortată a elementelor din
S. În alte cuvinte, k-mediana este un element x ∈ {a[0], . . . , a[n − 1]} cu
proprietăţile |{i | 0 ≤ i < n ∧ a[i] < x}| < k şi
|{i | 0 ≤ i < n ∧ a[i] ≤ x}| ≥ k (dacă toate lelementele din S sunt
distincte, atunci avem egalitate ı̂n ultima relaţie).

k-mediana
Aplicaţie: mediana unei mulţimi de puncte

k-mediana
k-mediana: problema
Presupunem S memorată ı̂ntr-un tablou.

Considerăm următoarea problemă:
Input un tablou (a[i] | 0 ≤ i < n) şi un număr k ∈ {0, 1, . . . , n − 1},
Output k-mediana
Evident, orice algoritm de sortare rezolvă problema de mai sus. Deoarece
cerinţele pentru selecţie sunt mai slabe decât cele de la ordonare, se pune
firesc ı̂ntrebarea dacă există algoritmi mai performanţi decât cei utilizaţi la
sortare.

k-mediana
k-mediana: descriere algoritm
Condiţia pe care trebuie să o satisfacă la ieşire tabloul a este formulată de:
(∀i)(i < k =⇒ a[i] ≤ a[k]) ∧ (i > k =⇒ a[i] ≥ a[k])
Fie j o poziţie ı̂n a astfel ı̂ncât:
(∀i)(i < j =⇒ a[i] ≤ a[j]) ∧ (i > j =⇒ a[i] ≥ a[j])
Un asemenea j poate fi obţinut cu algoritmul de partiţionare de la

quickSort. Dacă j = k atunci problema este rezolvată. Dacă j < k
atunci cel de-al k-lea cel mai mic element trebuie căutat ı̂n subtabloul
a[j+1..n], iar dacă j > k atunci cel de-al k-lea cel mai mic element
trebuie căutat ı̂n subtabloul a[1..j-1].

k-mediana
k-mediana: algoritmul recursiv
Aceasta conduce la următoarea formulare recursivă a algoritmului de

selectare:
@input: un tablou a cu n elemente, 0 ≤ k < n

@output: k-mediana
selecteaza(a, p, q, k) {
partitioneaza(a, p, q, j);
if (j == k) return a[k];
if (j < k) selecteaza(a, j + 1, q, k);
else selecteaza(a, p, j - 1, k);
}

k-mediana
k-mediana: algoritmul nerecursiv

Descrierea recursivă nu este avantajoasă deoarece produce un consum de
memorie suplimentară (stiva apelurilor recursive) ce poate fi eliminat prin
derecursivare:
@input: un tablou a cu n elemente, 0 ≤ k < n

@output: k-mediana
selecteaza(a, n, k) {
p = 0; 1 = n-1;
repeat
partitioneaza(a, p, q, j);
if (j < k) p = k1 + 1;
if (k < j) q = k1 - 1;
until (j == k);
return a[k];
}

k-mediana
k-mediana: analiza
Analiza algoritmului selecteaza este asemănătoare cu cea a algoritmului

quickSort. În cazul cel mai nefavorabil necesită O(n2 ) timp, iar pentru
complexitatea medie se cunoaşte următorul rezultat:
Teoremă
Complexitatea timp medie a algoritmului Selecteaza este O(n). Mai
precis, numărul de comparaţii este aproximativ:
n
n
n + k log + (n − k) log .
k n−k

k-mediana
Mediana in general: un rezultat ajutător

Proprietate: Fie dată o bară de lungime 1, care se taie arbitrar ı̂n două. Lungimea
3
medie a bucăţii mai lungi este .
4
Spaţiul continuu: Considerăm variabila aleatorie Y = max(u, 1 − u).
R 1 3
M(Y ) = 01 M(Y | Y = u)du = 02 (1 − u)du + 11 udu =
R R
2 4
1
Spaţiul discret: se ı̂mparte bara ı̂n n părţi egale de lungime
n
k n 2
n par: lungimile segmentelor mai lungi sunt ,k = + 1, . . . , n − 1, cu probabilitatea . Rezultă media egală cu
n 2 n−1
Pn−1 k 2 3n − 6 3
k=n/2+1
· = ≤
n n−1 4(n − 1) 4
k n+1 2
n impar: lungimile segmentelor mai lungi sunt ,k = , . . . , n − 1, cu probabilitatea . Rezultă media egală cu
n 2 n−1
Pn−1 k 2 3n − 1 3
k=(n+1)/2
· = ≤
n n−1 4n 4
3
La limită se obţine ı̂n ambele cazuri .
4
Concluzie: daca se ı̂mparte ı̂n două un tablou de lungime n, lungimea celui mare
3
subtablou este n.
4
k-mediana
Mediana in general: analiza
Intuitiv: Exp-Time(n) ≤ (n − 1) + Exp-TimeA ( 34 n)

Formal: Presupunem ca pivotul este ales aleatoriu.Avem
Exp-Time(n) = maxk Exp-Time(n, k)
Afirmăm că Exp-Time(n) ≤ 4n. Demonstrăm prin inducţie.
Pn−1
Exp-Time(n) ≤ (n − 1) + i=n/2 Exp-Time(i) =
(n − 1) + M(Exp-Time( n2 ), . . . , Exp-Time(n − 1))
Ipoteza inductivă: Exp-Time(i) ≤ 4i, i = n/2, . . . , n − 1
Avem Exp-Time(n) ≤ (n − 1) + M(4 n2 , . . . , 4(n − 1)) ≤ (n − 1) + 4 43 n < 4n

k-mediana
Un algoritm determinist liniar
[Manuel Blum, Robert W. Floyd, Vaughan Pratt, Ronald L. Rivest, and

Robert E. Tarjan. 1972. Linear time bounds for median computations.]
n
1 grupează tabloul ı̂n 5 grupe de 5 elemente şi calculează mediana
fiecărei grupe;
2 calculează recursiv mediana medianelor p
3 utilizează p ca pivot şi separă elementele din tablou
4 apelează recursiv pentru subtabloul potrivit (ı̂n care se află
k-mediana)

k-mediana
Un algoritm determinist liniar: analiza

Notaţii: T (n, k) timpul pentru cazul cel mai nefavorabil pentru k-mediana,
Tn = maxk T (n, k) Pasul 1: O(n)
Pasul 2: T (n/5)
Pasul 3: O(n)
3 3
pasul 4: presupunând că cel puţin 10 din tablou este ≤ p şi că cel puţin 10 din
7n
tablu este ≥ p, pasul recursiv ia cel mult T ( 10 ).
ı̂nsumând obţinem:
T (n) ≤ cn + T ( n5 ) + T ( 7n
10 )
2
n
≤ cn + c 5 + T ( 52 ) + T ( 5·10 ) + c 7n
n 7n
10 + T ( 7n
5·10 ) + T ( 710n2 ) ≤ . . . = O(n) (similar
teoremei de master).
3 3
Demonstrarea afirmaţiei ”cel puţin 10 din tablou este ≤ p şi că cel puţin 10 din
tablou este ≥ p”:
Fie g = n5 .
Cel puţin d g2 e dintre grupuri (cele cu mediana ≤ p) au cel puţin trei elemente ≤ p.
Rezultă că numărul de elemente ≤ p este cel puţin 3d g2 e ≥ 3n10 .
Analog pentru numărul de elemente ≥ p.
Comparaţi experimental cei doi algoritmi pentru mediană.

Compl Medie PDF

Î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

Compl Medie PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Proiectarea algoritmilor: complexitatea medie

Faculty of Computer Science

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 1 / 44

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 2 / 44

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 3 / 44

Fie P o problemă, p ∈ P instanţă a problemei P, A un algoritm care

Reamintim formula pentru complexitatea ı̂n cazul cel mai nefavorabil:

Uneori, numărul instanţelor p cu g (p) = n pentru care TA (p) = TA (n) sau

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 4 / 44

Exemplu de variabilă aleatorie: aruncarea a două zaruri

Experiment: aruncarea a două zaruri

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 5 / 44

Exemplu de variabilă aleatorie: aruncarea a două zaruri

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 6 / 44

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 7 / 44

Considerăm problema căutării unui element ı̂ntr-o secvenţă de numere

Presupunem că secvenţa (a0 , . . . , an−1 ) este memorată ı̂n tabloul a.

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 8 / 44

Algoritmul A1 descris de următorul program rezolvă P1 :

//@input: un tablou a cu n elemente, z

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 9 / 44

Timpul mediu pentru A1

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 11 / 44

∀i 0 : p ≤ i 0 < i =⇒ a[i 0 ] ≤ x (1)

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 14 / 44

Quicksort: algoritmul de partiţionare

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 15 / 44

După sortarea recursivă a subtablourilor a[p..k − 1] şi a[k + 1..q] se

@input: a = (a[p], . . . , a[q])

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 16 / 44

Quicksort: timpul ı̂n cazul cel mai nefavorabil

Cazul cel mai nefavorabil se obţine atunci când la fiecare partiţionare se

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 17 / 44

Quicksort: timpul mediu

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 18 / 44

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 19 / 44

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 20 / 44

Funcţia random ı̂n Alk

Următorul exemplu este un generator de numere pseudo-aleatorii din

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 22 / 44

Agoritmi nedeterminişti: exemplu

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 23 / 44

Agoritmi nedeterminişti: demo

$ krun programs/ex1.alk -cST="x |-> { .Map }" -cSEED="1214"

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 24 / 44

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 25 / 44

Timpul mediu de execuţie al algoritmilor probabilişti

ProbA,x (C ) = probabilitatea cu care algoritmul A execută calculul C

D. Lucanu (FII - UAIC) Complexitatea medie PA 2014/2015 27 / 44

1 Timpul mediu: algoritmi determinişti

2 Timpul mediu: algoritmi probabilişti