Sunteți pe pagina 1din 9

Seminar 2

Probleme
1. Calculul complexitii in cazul sortrii prin inserie

S se calculeze T(n) pentru algoritmul de sortare prin inserie.
Notaii: A tabloul de sortat (numere ntregi)
n lungime[A]
c
i
costul instruciunii din linia respectiv (de obicei n uniti de timp)
t
j
numrul de execuii ale testului din linia 4 (pentru fiecare j = 2,3...lungime[A]
Procedura sortInsert (A) Cost instruciune Numr execuii
1
pentru j 2, lungime[A] execut
c
1
n-1
2
Temp A [j]
c
2
n-1
3
i j 1
c
3
n-1
4 ctTimp (i > 0 i Temp < A[i]) execut c
4

n
2 j
j
t
5
A [i +1] A [i]
c
5


n
2 j
) 1
j
t (
6
i i 1
c
6


n
2 j
) 1
j
t (
7 sfCtTimp
8
A [i +1] Temp
C
8
n 1
9 sfPentru
sfProcedur
Atunci:
) 1 (
8
c ) 1
2
j
(t
6
c ) 1
2
j
(t
n
2 j
5
c
j
t
4
c 1) (n
3
c 1) (n
2
c 1) (n
1
c T(n) +

+

+ + + +

n
n
j
n
j
Pentru a calcula efectiv T(n) vom considera 3 cazuri.
1
o
. Cazul cel mai favorabil cnd A e sortat cresc tor
Pentru fiecare j = 2,3...lungime[A] avem Temp A[i] t
j
= 1.
Deci
1) (n
8
c 0
6
c 0
5
c 1) (n
4
c 1) (n
3
c 1) (n
2
c 1) (n
1
c T(n) + + + + + +

)
8
c
4
c
3
c
2
c
1
c ( - n )
8
c
4
c
3
c
2
c
1
c ( + + + + + + + +
= an + b = (n)
(o funcie liniar de n)
2
o
. Cazul cel mai nefavorabil cnd A e sortat descresc tor
Pentru fiecare j = 2,3...lungime[A] avem Temp < A[i] t
j
= j
iar
1
2
1) n(n
j t
n
2 j
n
2 j
j

+



i
2
1) n(n
j ) 1 (j 1) (t
1 - n
1 j
n
2 j
n
2 j
j




Deci:
1) (n
8
c
2
1) - n(n
6
c
2
1) - n(n
5
c 1
2
1) n(n
4
c 1) (n
3
c 1) (n
2
c 1) (n
1
c T(n) +
,
_

+
,
_

+
,
_

+
+ + +
= an
2
+ bn+c = O(n
2
) (o funcie polinomial ptratic de n)
1
3
o
. Cazul mediu cnd
Pentru fiecare j = 2,3...lungime[A] avem t
j
= j/2, adic jumtate din elementele secvenei sunt
sortate cresctor, o presupunere destul de realist
iar
,
_

+



1
2
1) n(n
2
1
2
j
t
n
2 j
n
2 j
j
i
4
1) 2)(n - (n
2) - (j
2
1
) 1
2
j
( 1) (t
n
2 j
n
2 j
n
2 j
j




Deci
T(n)
an
2
+ bn+c = O (n
2
) (o funcie polinomial ptratic de n)
Concluzie: T(n)=O(n
2
)
2. Sortrile fr comparaii ntre elementele secvenei
a) Sortarea distribuiilor (MathSort), determinarea T(n)=O(n), deci complexitate liniar
b) Sortarea prin evaluarea cifrelor (RadixSort), determinarea T(n)=O(n), deci complexitate
liniar
3. S se determine complexitatea (T(n)=?) pentru algoritmul
Pt i 1, n execut C
1
j i C
2
CtTimp j 0 execut C
3
j j div 2 C
4
SfCtTimp
SfPt
Cost instruciune Numr execuii
C
1
n
C
2
n
C
3

n
1 i
i
t
C
4

n
1 i
) 1
i
t (
Avem
[ ] n 2 n nlog n 2 n log ... 2 log 1 log t 2 i log t
2 2 2 2
n
1 i
i 2 i
+ + + + + +

[ ] n n nlog n n log ... 2 log 1 log ) 1 (t 1 i log 1 t


2 2 2 2
n
1 i
i 2 i
+ + + + + +

T(n) = (c
1
+c
2
)n + c
3
(nlog
2
n

+ 2n) +

c
4
(nlog
2
n +n)=
= (c
1
+c
2
+2c
3
+c
4
) n + (c
3
+c
4
) nlog
2
n = O(n *log
2
n).
2
4. Turnurile din Hanoi
Procedura Hanoi(n,A,B,C)
Daca n=1
Atunci @ Se muta discul 1 de pe A pe B
Altfel Hanoi (n-1, A,C,B)
@ Se muta discul n de pe A pe B
Hanoi (n-1,C,B,A)
SfDaca
SfProcedura
Recurena dedus este

'

> +

1 n 1, 1) 2T(n
1 n 1,
T(n)
Rezolvare: iterm i adunm membru cu membru apoi reducem:
T(n) = 2T(n-1) + 1
2T(n-1) = 2
2
T(n-2) + 2
2
2
T(n-2) = 2
3
T(n-3) + 2
2
- - - - - - - - - - - - - - - - - - - - - - - - - - - -
2
n-2
T(2) = 2
n-1
T(1) + 2
n-2
______________________________________
T(n)= 1 + 2 + 2
2
+ ... +2
n-2
+ 2
n-1
= ). 2 ( 1 2
1 2
1 2
n n
n

5. Probleme pentru teorema Master.


Reamintim metoda Master
Aceast metod se aplic problemelor recursive care au timpul de execuie de forma:
c) (asimptoti 0 f(n) 1, b 1, a cu f(n), ) b n aT( T(n) > > +
Avem 3 cazuri (demonstrate n CORMEN, THOMAS H. LEISERSON, CHARLES
RIVEST, RONALD R.: Introducere n algoritmi. Cluj-Napoca: Editura Computer Libris Agora,
2000).
1
o
Dac ( )

a
b
n O n f
log
) ( pentru o anumit constant ( )
a
b
n n T
log
) (
2
o
Dac ( )
a
b
n n f
log
) (
( ) n n n T
a
b
2
log
log ) (
3
o
Dac ( )
+

a
b
n n f
log
) ( , pentru o anumit constant > 0, i dac
( ) ) (n cf b n af
(numit i condiie de regularitate) pentru o constant c i n suficient de mari, atunci
( ) ) ( ) ( n f n T
Observm c practic se compar f(n) cu
a log
b
n
i soluia o va da cea mai mare dintre ele; f(n)
trebuie s fie polinomial mai mic (n primul caz) i polinomial mai mare (n cazul 3) dect
a log
b
n
.
3
S se rezolve:
T(n) = 4T(n/2) +n; T(n) = 4T(n/2) +n
2
;
T(n) = 4T(n/2) +n
3
; T(n) = 2T(n/2) +n
3
;
T(n) = T(9n/10) +n; T(n) = 16T(n/4) +n
2
;
T(n) = 7T(n/3) +n
2
; T(n) = 7T(n/2) +n
2
;
T(n) = 2T(n/4) + n ; T(n) = 3T(n/2) +nlog
2
n;
T(n) = 2T(n/2) +n/log
2
n; T(n) = T(n-1) +n;
T(n) = T( n ) +1 T(n) = T(n-1) +1/n;
T(n) = T(n-1) +log
2
n; T(n) = n T( n ) +n;
T(n) = T(n/2) + (1); cutare binar
6. Alte probleme:
a) Problema steagului olandez (bile de 3 culori, amestecate la nceput, trebuie puse compact
pe culori distincte, parcurgnd o singur dat secvena de bile)
b) S se arate c parcurgnd o singur dat o secven de n elemente se poate determina att
valoarea minim ct i valoarea maxim efectund cel mult 3*[n/2] +C comparaii unde
C este o constant ce trebuie determinat.
c) Algoritmi pe o tabl de operaii (asociativitate, comutativitate, elemente neutru, element
invers) cu determinarea complexitii, se poate da ca i tema de cas;
d) Pentru urmtoarea secven de pseudocod s se numere cte atribuiri se fac:
Pentru i n-2,-2,-1 executa // n ntreg
Pentru j i+3,n executa
@ o(una) atribuire
SfPentru
SfPentru
Rezolvare posibil:
Pentru valorile lui n <1 avem nr(atribuiri)=0.
Pentru n 1:
Nr(atribuiri) =
( ) ( )
2
) 1 (
0 1 ... 2 2 1
1 , 2
2
2
2
1 , 2
2 3
1 , 2
2
+
+ + +




+


n n
n i n i n t
n i
n
i n i
n
i j n i
i
Altfel: vom ncerca s dm valori succesive lui n apoi s vedem ce mulimi parcurg
indicii i i j;
Pentru nceput observm c trebuie ca n-2-2, pentru ca s se intre n primul ciclu deci
n0. Concluzie pentru valorile lui n {..., -3,-2,-1} nr(atribuiri)=0.
n tabelul urmtor vom da valorile indicilor i i j
n i j atribuiri
0
i{-2} j
0
4
1
i{-1,-2}
i=-1 avem j
i=-2 avem j{1}
1 total 1
2
i{0,-1,-2}
i=0 avem j
i=-1 avem j{2}
i=-2 avem j{1,2}
1
2 total 3
3
i{1,0,-1,-2}
i=1 avem j
i=0 avem j{3}
i=-1 avem j{2,3}
i=-2 avem j{1,2,3}
1
2
3 total 6

Concluzia nr(atribuiri)=n(n+1)/2, pentru n 1.
7. Se execut pe dou calculatoare 2 programe de sortare pentru a sorta 1 milion (10
6
) de numere.
Primul calculator este un SuperComputer(notat Super) care execut 10
8
operaii pe secund, iar
al 2-lea este un PC care execut 10
6
operaii pe secund.
Pe Super s-a codificat un program de sortare care are T(n) = 2n
2
, iar pe PC s-a implementat un
program cu T(n) = 50nlog
2
n. S vedem ce nevoie de timp are fiecare computer:
Pentru Super:
( )
ore 56 , 5 sec 20000 10 2
10
10 2
ni/sec instructiu 10
ni instructiu 10 2
4
8
12
8
2
6

Pentru PC:
( )
minute 67 , 16 sec 1000 sec 10 * 2 50
ni/sec instructiu 10
ni instructiu 10 log 10 50
6
6
2
6


8. Despre Heap-ul binar.
ReMakeHeap - pentru ntreinerea proprietii de heap;
BuildHeap - genereaz un heap dintr-un vector neordonat, furnizat la intrare.
HeapSort - ordoneaz un vector n spaiul alocat acestuia.
Reconstituirea proprietaii de Heap (ReMakeHeap).
-se presupune c la apel pentru nodul i, subarborii cu radacina STANGA(i) i DREAPTA(i) sunt
heap-uri.
-sarcina procedurii este de a scufunda in HEAP pe A[i] astfel nct subarborele, care are
radcina valorii A[i] s devin un heap.
Procedure ReMakeHeap(A,i)
l STANGA(i) // l=2i
r DREAPTA(i) // l=2i+1
Daca l DimHeap[A]si A[l] > A[i]
Atunci maxim l
Altfel maxim i
SfDaca
Daca r DimHeap[A] si A[r] > A[maxim]
Atunci maxim r
SfDaca
Daca maxim i
Atunci
A[i] A[maxim]
ReMakeHeap (A,maxim)
SfDaca
SfProcedura.
Complexitate
Dimensiunea unui subarbore binar este cel mult 2n/3, pentru un arbore binar de n noduri.
5
Deci T(n)T(2n3)+(1) > T(n)=0(log
2
n)

Suntem n cazul 2 al teoremei master:
a=1, b=3/2, f(n) = (1)
) 1 ( ) (
0 1 log log
2 / 3
n f n n n
a
b
> T(n)=0(log
2
n) sau pentru nlimea h avem O(h).
Dm n continuare procedura de construire a unui heap dintr-un vector:
Procedure BuildHeap(A)
DimHeap[A] Lungime[A]
Pentru i [ ] /2 Lungime[A] ,1,-1 executa
ReMakeHeap(A,i)
SfPentru
SfProcedura.
Complexitate
Pentru o nalime h oarecare (interioar, nlimea arborelui fiind log
2
n) a unui arbore binar
aproape complet de n noduri, exist cel mult
1
1
1

+1 h
2
n
noduri de nlime h.
Avem
] ]
O(n)
2
h
n
2
1
O
2
h
n
2
1
O O(h)
2
n
0 h
h
n log
0 h
h
n log
0 h
1 h
2 2

,
_

,
_

1
1
1

1
1
1




+
deoarece:
( )
2
2 1 1
2 1
2
h
2
0 h
h

, aplicnd formula
( )



0 k
2
k
x 1
x
x k
, pentru x=1/2.
Dm n continuare procedura de sortare a unui heap:
Procedure HeapSort(A)
BuildHeap(A)
Pentru i Lungime[A] ,2,-1 executa
A[1] A[i]
DimHeap[A] DimHeap[A]-1
ReMakeHeap(A,1)
SfPentru
SfProcedura.
Complexitatea este evident: T(n) = O(n) +O(nlog
2
n) = O(nlog
2
n)
9. S se arate c un polinom de gradul k are complexitatea O(n
k
).
Fie polinomul P(n)= a
0
+ a
1
n +...+a
k
n
k
, n>0.
Trebuie s artm c: c>0 astfel nct: P(n) c*n
k
Avem P(n) |P(n)|=|a
0
+ a
1
n +...+a
k
n
k
| |a
0
| + |a
1
|n +...+|a
k
|n
k
=
( )
k
n | a | ... | a | | a |
1
| a |
...
1 k
n
| a |
k
n
| a |
k
n
k 1 0
k 1 0
+ + +

,
_

+ +

+
Deci c=|a
0
|+|a
1
|+...+|a
k
|.
10. Arbori de decizie
6
Sortrile prin comparaie pot fi vizualizate n mod abstract prin arborii de decizie. Un arbore de
decizie reprezint comparaiile realizate ale uni algorim de sortare, cnd acesta opereaz asupra unor
date de intrare avnd o mrime data n.
Fie tabloul de sortat A=(a
i
, i=1,n).
Fiecare nod este este etichetat astfel:
- nodurile interne (inclusiv rdcina) este etichetat cu a
i
:a
j
semnificnd comparaia celor
dou elemente, evident i,j{1,...,n}, ij
- fiecare frunz este etichetat cu o permutare <(1),(2),..., (n)> semnificnd o
sortare a elementelor tabloului A.
Execuia algoritmului de sortare corespunde trasrii unui drum de la rdcina arborelui la o
frunz.
n fiecare nod intern e fcut compararea a
i
a
j.
Subarborele stng dicteaz comparaiile urmtoare
pentru a
i
a
j ,
iar subarborele drept dicteaz comparaiile pentru a
i
> a
j
. Cnd ajungem la o frunz
avem ordonarea: a
(1)
a
(2)
... a
(n)
. Deci avem n! frunze.
Exemplu pentru n=3.
sau ntr-o alt variant mai explicit:
7
Lungimea celeui mai lung drum (ca numar de muchii) de la rdcina unui arbore de decizie la oricare
dintre frunzele sale reprezint numrul de comparaii n cel mai nefavorabil caz, pe care le realizeaz
algoritmul de sortare. Deci, numrul de comparaii n cel mai nefavorabil caz = nlimea arborelui
de decizie.
Teorem. Oricarea ar fi un arbore de decizie (asociat unei sortri prin comparare a n elemente) el are
nalimea: (nlog
2
n)
Demonstraie:
- fie un arbore de decizie cu nlimea h pentru sortarea a n elemente;
- un arbore binar avnd nlimea h nu are mai mult de 2
h
frunze, deci n! 2
h
log
2
(n!) log
2
(2
h
) h log
2
(n!);
- din aproximarea lui Stirling avem: , !
n
e
n
n
,
_

pentru c:

,
_

,
_

+
,
_

n
n
e
n
n n
1
1 2 !
- h log
2
(n!) ( )
,
_


,
_

e n n
e
n
n
n
e
n
2
log
2
log
2
log
2
log (nlog
2
n)
Tip sortare Caz nefavorabil Caz Mediu
1. Bubble Sort (n
2
) (n
2
)
2. Selectie (n
2
) (n
2
)
3. Insertie (n
2
) (n
2
)
4. Quick Sort
O(n
2
)
(nlog
2
n)
5. MergeSort (nlog
2
n) (nlog
2
n)
6. HeapSort (nlog
2
n) (nlog
2
n)
7. CountSort (n
2
) (n
2
)
8. ShellSort (n
2
) (n
2
)

11. Sortarea prin numrare fr comparare (MathSort)
- fiecare din cele n elemente ale tabloului A (A=(a
i
, i=1,n)) este un numr ntre 1 i k (dat)
dac k=O(n) atunci sortarea are complexitatea O(n).
- idea const n a numra cte elemente sunt mai mici dect un element oarecare x: C(x);
dac elementele sunt distincte atunci e evident c x se va afla pe poziia C(x)+1;
- se modific algortimul cnd elementele nu sunt distincte;
algoritmul mathSort(A,B,k) //A tabloul iniial, B tabloul de iesire,
{ //C tablou de lucru
Pentru i1,k executa
C[i] 0
SfPentru
Pentru j1,lungime[A] executa //lungimea lui A este n
C[A[j]] 0 C[A[j]]+1 //C[i] va contine numarul de elemente
SfPentru //egale cu i

Pentru i2,k executa
C[i] C[i]+C[i-1] //C[i] va contine numerul de elemente mai
SfPentru //mici sau egale cu i
Pentru j1,lungime[A] executa
B[C[A[j]] A[j]
C[A[j]] C[A[j]-1
SfPentru
}
12. RadixSort (sortarea prin evaluarea cifrelor elementelor)
8
13. Aplicatii la vector (array)
TAD Polinom. Sa se scrie doi algoritmi pt. calculul valoarea unui polinom intr-un punct .si pt suma
polinoamelor. Se cere ca unul dintre algoritmi s aiba complexitatea de ordinul (n), iar celalalt - de
ordinul: (n
2
).
Discutie despre DS folosita:
- Pt pol de gr. N folosesc un array de n+1 elem
- Sau folosesc un vector dinamic cu elemente (grad,valoare)
14. Propunere de tem. Se considera problema de a determina dac un ir arbitrar de numere contine cel
puin 2 termeni egali. Artai c exist un algoritm care rezolv aceast problem n (n log(n)).
9