Teorema Master

n


+ O nd
T (n) = a T
b
a = numarul de subprobleme, a > 0
b = rata de descrestere a dimensiunii subproblemelor,
b>1


d
d = exponentul
din Div(n)
O n ,d>0

+ Comb(b)
d
d
O n
log(n) a = b
O nd

a < bd
T (n) =

a > bd
O nlogb a
0

a
n
b

h = logb n

n
b2

...

n
b

...

n
b2

n
b2

...

1
n
b2

n
bj

aj = numarul de subprobleme la nivelul j

n
= dimensiunea subproblemelor de la nivelul j
bj
Avem alogb n = nlogb a frunze.
  
n d
T (nivelj) a O
bj
 n d
= aj c j
b
 a j
= c nd d
b
j

Avem:
(
(i) T (1) c
(ii) T (n) a T

n
b

+ c nd
logb n

Total =

T (nivel j)

j=0
logb n

c nd

 a j

j=0

bd

logb n 

=cn

j=0

a j
bd
{z }

logb n

rj

j=0
serie geom.

r=

a
bd

ratia

P

a
logb n j
T (n) c nd
r
, r= d
j=0
b
Sume de serii geometrice

rk+1 1
, daca r =
6 1
1 + r + r2 + + rk =
r

1
k + 1,
daca r = 1
(1) daca r = 1,

Plogb n
j=0

rj = numarul de termeni = k + 1

(2) daca r < 1,

log n

sumj=0b rj

1
1r

(3) daca r > 1,

log n
sumj=0b rj

1
1+
r1

1
1
, at si 1 +
, sunt independente de k (cazurile (2) si (3)).
1r
r1
Cazul (1) (r = 1) a = bd :
Obs.: Atat

T (n) c nd (logb n + 1)


= O nd log n
Cazul (2) (r < 1) a < bd :

T (n) c nd

=O n

a
1 d
| {zb }

constant
d

Cazul (3) (r > 1) a > bd :



1
T (n) c nd 1 +
rlogb n
r1
|
{z
}
constant
 a logb n
alogb n
alogb n
Din rlogb n = d
=
=
rezulta:
logb n )d
b
nd
(b


T (n) O alogb n Amintim ca numarul de frunze este: alogb n = nlogb a .
| {z }
nr. de frunze

C
autare binar
a
CautBin(x, A[1..n])

(1)

n
2

// vectorul A este ordonat descrescator

hni

1. if x = A
then
2
2.
gata
3. else
hni
then
4.
if x < A
2
h n
i
5.
CautBin x, A 1.. 1
2
6.
else
i

hn
+ 1..n
7.
CautBin x, A
2
8.
endif
9. endif

n
T (n) = T
+ (1)
2
a = 1, b = 2, d = 0
n
aT
+ (nd )
2
a = bd T (n) = O(log n)
caz 1

Merge Sort
n
+ (n)
T (n) = 2 T
2
a = 2, b = 2, d = 1
a = bd T (n) = O(n log n)
caz 1

Quick Sort
QuickSort(A[1..n])
1. k Partitie(A) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Divide = (n)
2. QuickSort(A[1..k 1]) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . apel recursiv 1
3. QuickSort(A[k + 1..n]) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . apel recursiv 2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conquer = 0
Cazul cel mai favorabil
n
k = (la toate!)
2
n
T (n) = 2 T
+ (n)
2
a = 2, b = 2, d = 1
a = bd T (n) = O(n log n)
caz 1

Inmultirea a dou
a numere de lungime n
Algoritmul ,,direct O (n2 )
Algoritmul ,,Divide et Impera (Gauss/Karatsuba)

x = xL xR

y = yL yR

n
= 2 2 xL + xR
n
= 2 2 yL + yR

n
x y = 2n xL xR +2 2 xL yR + xR yL + xR yR
| {z }
| {z } | {z }
| {z }
T (n) = 4 T

n

+ O(n)
2
a = 4, b = 2, d = 1
a > bd T (n) = O(nlog2 4 ) = O (n2 )
caz 3

De la 4 apeluri recursive la 3
n
+ O(n)
T (n) = 3 T
2
a = 3, b = 2, d = 1
a > bd T (n) = O(nlog2 3 ) = O (n1,59 )
caz 3