Sunteți pe pagina 1din 36

Paradigma algoritmilor greedy

Prezentarea generala a paradigmei


Studii de caz
memorarea programelor
rucsac (varianta continua)
arbori Huffman
Algoritmi greedy - ingrediente
probleme de optim
proprietatea de alegere locala (greedy)
solutia de optim global poate fi obtinuta facind alegeri
optime locale (greedy)
alegerea optima locala curenta poate depinde de alegerile
de pina atunci dar nu si de cele viitoare
trebuie demonstrat ca alegerile optime locale conduc la
obtinerea optimului global
proprietatea de substructura optima
solutia optima a problemei contine solutiile optime ale
subproblemelor

Algoritmi greedy o prima formalizare
S o multime de intrari
C(S)
obiectele din C(S) sunt submultimi ale lui S
operatii: X {x}, X {x}
Problema
Intrare: S, f : C(S) R
Iesire: B obiect maximal din C(S) care optimizeaza f
B este construita incremental
Alegerea locala
alege x a. i. B {x} e C(S)
x defineste un optim local
proprietatea de substructura optima
fie x primul (sau ultimul) ales de alg. greedy
solutia problemei initiale include solutia subproblemei
coresp. lui S = S {x}, C(S) = {B _ S | B {x} e C(S)},
f restrictionata la C(S)
Memorarea eficienta a programelor - formulare
instanta
n obiecte 0,1, ..., n-1 de marimi (lungimi) L
0
, L
1
, ..., L
n-1

presupunem cele n obiecte asezate intr-o lista liniara in ordinea
(t(0), ..., t(n-1))
timpul de regasire a obiectului de pe pozitia k este
t(k) =
i=0,k
L
t(i)
timpul mediu de regasire este TM(t) = 1/n
k=0,n-1
t(k)
iesire
o asezare a obiectelor in lista a.i. timpul mediu de regasire sa
fie minim

Memorarea eficienta a programelor algoritm greedy
exemplu
L = (40, 10, 60, 30)
TM(id) = (40 + 50 + 110 + 140)/4 = 340/4 = 85
t = (1, 3, 0, 2)
TM(t) = (10 + 40 + 80 + 140) = 270/4 < 85
algoritm greedy: alege la pasul curent un obiect neales inca
de lungime minima
alegerea greedy duce la obtinerea optimului global
t o permutarea a.i. i < j si L
t(i)
> L
t(j)

t = t(i,j) (t inmultit cu transpozitia (i,j))
TM(t) < TM(t)
rezulta ca t este optima daca (i,j) i < j L
t(i)
s L
t(j)

permutarea calculata de alg. greedy satisface ac. prop.
proprietatea de substructura optima (?)
timp: O(n log n)
spatiu suplimentar: O(1)
Memorarea eficienta a programelor algoritm greedy, formal
S = {(i,j) | 0 s i, j < n}
X e C(S) daca:
((i,j), (i,j) e X) i = i j = j
alegerea locala:
(k, i) a.i. k este prima pozitie libera si L(i) minim peste
obiectele nealese
B B {(k,i)}
in final B descrie permutarea t care ordoneaza obiectele
crescator dupa marime
proprietatea de substructura optima
permutarea t include permutarea ce ordoneaza
crescator dupa marime obiectele {0,1,,n-1} t(0)
(eliminarea celui mai mic obiect)
Problema rucsacului (varianta continua): formulare
instanta:
n obiecte 0, 1, ..., n-1 de dimensiuni (greutati)
w
0
, w
1
, ..., w
n-1
un rucsac de capacitate M
introducerea in rucsac a unei parti fractionare x
i
din
obiectul i aduce un profit x
i
p
i
profitul total adus de alegerile x
0
, ..., x
n-1
este

i=0,n-1
x
i
p
i

iesire:
o alegere pentru care profitul adus este maxim
Problema rucsacului: solutie greedy care nu-i OK
la pasul curent alege obiectul cu profitul p
i
cel mai mare
contraxemplu:
n = 3, p = (3, 4, 6), w = (6, 4, 8), M = 10
profitul = 8 cu alegerea (0, , 1)

Problema rucsacului: solutie greedy OK
la pasul curent
alege obiectul ce aduce profit maxim pe unitatea de
greutate (p
i
/w
i
)
daca este loc suficient in rucsac, obiectul se introduce in
totalitate (x
i
= 1)
altfel obiectul este introdus partial (maxim din cit se
poate, 0 s x
i
< 1) si procesul de alegere se opreste
exemplu (continuare):
p/w = (3/6, 4/4, 6/8)
profitul = 17/2 cu alegerea (0, 1, 6/8)
Teorema Solutia calculata de algoritmul greedy este optima
demonstratie
timp: O(n log n)
spatiu suplimentar: O(n)
Problema rucsacului: solutie greedy, formalizare
S = {(i,x) | 0 s i < n, x e [0,1]}
X e C(S) daca:
((i,x), (i,x) e X) i = i x = x
(xw
i
| (i,x) e X) s M
alegerea locala:
(i, x
i
) a.i. i aduce profit maxim pe unitatea de greutate si
x
i
cantit maxima ce incape in rucsac
B B {(i, x
i
)}
proprietatea de substructura optima
solutia x include solutia xcorespunzatoare
subproblemei P obtinuta din P prin eliminarea
obiectului i cu profit maxim pe unitatea de greutate si
M = M x
i


Coduri Huffman
Coduri liber (independent) de prefix optime
instanta
n mesaje M
0
, M
1
, ..., M
n-1
cu frecventele f
0
, f
1
, ..., f
n-1
cod(M
i
) e {0,1}*, i,j: i = j cod(M
i
) nu este prefix a lui
cod(M
j
)
lungimea medie a codificarii = 1/n
i=0,n-1
(|cod(M
i
)|f
i
)

iesire
o codificare cu lungimea medie minima
Coduri Huffman: reprezentarea unei codificari ca arbore
HARABABURA
1
2
4
1
2
0
0
1
0
1
0
1
1
1
0
0
H
R
A
B
U
M
i
H A R B U
f
i
1 4 2 2 1
cod(M
i
) 0010 011 010 10 110
Coduri Huffman: algoritm greedy
initial: n arbori cu un singur nod etichetati cu f
i

f
0

f
1

f
n-1

pasul curent
n
1

n
2

n
1

n
2

n
1
+ n
2

cu n
1
, n
2
minime peste multimea radacinilor
T
1
T
2
T
1
T
2
Proprietati ale codurilor Huffman
Lema
Fie cod o codificare optima.
Daca f
i
< f
j
atunci |cod(M
i
)| > |cod(M
j
)| (mesajele cu frecvente
mai mari au lungimile codurilor mai mici)

demonstratie
Lema
Orice codificare optima poate fi transformata intr-o codificare
Huffman cu aceeasi lungime medie.

demonstratie
Coduri Huffman: algoritm greedy, formalizare
S cea mai mica multime de arbori construita astfel:
f
i
e S
T
1
, T
2
e S T
1
T
2
e S

X e C(S) daca:
(Te X) T = f
i
sau (- T
1
, T
2
e X) T = T
1
T
2
X este finita
f(X) = max{suma_ponderata(T) | T e S}
alegere locala
B = B {T
1
T
2
}, T
1
, T
2
cu radacini minime in B si T
1
T
2

nu este in B
proprietatea de substructura optima
solutia problemei coresp. intrarii f
0
, f
1
, ..., f
n-1
include
solutia subproblemei coresp. intrarii f
0
+ f
1
, ..., f
n-1
, unde f
0
,
f
1
sunt minime
Coduri Huffman: implementare
initial cele n noduri se afla in heap-ul A
la pasul curent:
se extrag primele doua radacini n1 si n2 din heap-ul A
se introduce n1+n2 in heap-ul A
se adauga n1 si n2 la B
A se micsoreaza cu o unitate, B se mareste cu doua unitati, C
scade cu o unitate
timp: O(n log n)
spatiu: O(n)
stg
drp
0 1
A = min-heap
cu radacinile
B = noduri care
nu-s radacini
C = zona
auxiliara
. . .
inf
Paradigma algoritmilor greedy (continuare)
Studii de caz
arborele partial de cost minim
secventializarea activitatilor
Prezentarea formala a paradigmei

Arborele partial de cost minim - formulare
instanta:
un graf ponderat (G, w), G = (V, E), w : E R
arbore = graf conex fara cicluri
subgraf partial: G = (V, E) cu E _ E
arbore partial = subgraf partial + arbore
costul unui arbore partial este w(G) =
{i,j}eE
w({i,j})
iesire:
un arbore partial de cost minim
Arborele partial de cost minim algoritm generic
procedure APCM(G, w)
begin
A C
E1 E
while ((V, A) nu este arbore partial) do
alege din E1 o muchie {i,j} sigura pentru A
E1 E1 - {{i,j}}
A A {{i,j}}
end
muchia {i,j} sigura pentru A A {{i,j}}este
submultime a unui arbore partial de cost minim
Arborele partial de cost minim algoritmul lui Kruskal
A este o padure
pasul de alegere locala alege o muchie de cost minim ce
uneste doi arbori din A
structura de date pentru A: union-find
20
10
40
30
10
30
20
50
20
10
10
30
Arborele partial de cost minim algoritmul lui Kruskal (cont)
procedure APCM_Kruskal(G, w)
begin
A C
for each i in V do single(i)
sorteaza E crescator dupa w
for each {i,j} in E in ordine crescatoare do
if (find(A, i) = find(A, j)
then union(A, i, j)
end

Complexitate: O(m log m), unde m este numarul de muchii
Algoritmul lui Kruskal - formalizare
S = multimea de muchii
X e C(S) daca X este padure
alegere locala:
adauga la B muchia {i,j} de cost minim a.i.
{i,j} uneste doi arbori din B (B {{i,j}} e C(S) )
{i,j} de cost minim peste muchiile care satisfac
proprietatea de mai sus
proprietatea de substructura optima
muchia {i,j} adaugata prima data imparte B in doi subarbori:
B1=(V1, E1), B2 = (V2, E2) cu V = V1 V2
fie G1, G2 subgrafurile induse de V1 resp. V2
B1 este APCM pentru G1 si B2 este APCM pentru G2
Arborele partial de cost minim algoritmul lui Prim
A este arbore cu radacina r
pasul de alegere locala alege o muchie de cost minim ce se poate
adauga la A mentinind proprietatea de arbore
structura de date pentru A: arbore reprezentat prin legatura parinte
structura de data pentru E1: un min-heap Q cu cheie[i] = ponderea
minima peste ponderile muchiilor ce unesc pe i cu un virf ales deja
20
10
40
30
10
30
20
50 20
10
10
30
50
40
Arborele partial de cost minim algoritmul lui Prim
procedure APCM_Prim(G, w, r)
begin
Q V
for fiecare i in Q do cheie[i]
cheie[r] 0; parinte[r] -1
while (Q = C) do
citeste(Q,i); elimina(Q)
for (fiecare j in listaDeAdiac[i]) do
if (j e Q and w({i,j}) < cheie[j])
then parinte[j] = i;
cheie[j] w({i,j})
end
Complexitate asimptotica: O(n log n)+O(m log n) = O(m log n), unde
m este numarul de muchii si n este numarul de varfuri
Algoritmul lui Prim- formalizare
S = multimea de muchii
X e C(S) daca X este arbore
alegere locala:
adauga la B muchia {i,j} de cost minim a.i.
B {{i,j}} arbore (e C(S) )
{i,j} de cost minim peste muchiile care satisfac
proprietatea de mai sus
proprietatea de substructura optima
fie {i,j} ultima muchie aleasa a.i. j nu e in arbore inainte de
alegerea locala
B {{i,j}} este APCM pentru graful indus de V {j}
Secventializarea optima a activitatilor: formulare
Intrare:
n activitati 0,1,2, ,n-1
fiecare activitate dureaza o unitate de timp
realizarea activitatii i aduce profitul p(i) > 0
activitatea i trebuie terminata la termenul limita d(i)
(deadline)
Iesire
o lista liniara s = (s(0),, s(k-1)) de activitati a.i.
orice activitate s(i) este realizata in termen, d(s(i)) > i+1
profitul este maxim


Secventializarea optima a activitatilor: exemplu
o solutie posibila: (0, 3,1) cu profitul 20 + 25 + 35 = 80
d(0) = 2 > 1, d(3) = 2 > 2, d(1) = 3 > 3
o alta solutie posibila: (2, 3,1) cu profitul 35 + 25 + 35 = 95
d(2) = 1 > 1, d(3) = 2 > 2, d(1) = 3 > 3
exista vreo solutie mai buna?
i 0 1 2 3
d(i) 2 3 1 2
p(i) 20 35 35 25
Secventializarea optima a activitatilor: model mat.
solutie acceptabila: s = (s(0),, s(k-1)) a.i.
(i) d(s(i)) > i+1 (orice activitate este realizata in timp)
solutia optima: s* a.i. s* aduce profit maxim peste solutiile
acceptabile

i
p(s*(i)) = max{
i
p(s(i)) | s acceptabila}
reordonarea unei solutii acceptabile in ordinea crescatoare a
termenelor limita produce tot o solutie acceptabila

i 0 1 2 3
d(i) 2 3 3 2
(2, 0, 1) solutie acceptabila (0, 2, 1) solutie acceptabila

Rezulta ca putem reprezenta o solutie acceptabila ca o multime: {0, 1, 2};
secventa acceptabila se obtine ordonand multimea dupa termenii limita
Secventializarea optima a activitatilor: model mat.
criteriul de alegere locala:
B B {i}
unde i este activitatea de profit maxim a.i. B {i} este
solutie acceptabila

Teorema. Daca B este determinata de algoritmul greedy, atunci
orice secventializare acceptabila a lui B este optima.
i 0 1 2 3
d(i) 2 3 1 2
p(i) 20 35 35 25
B = B = {1} B = {1,2} B = {1,2,3} s = (2,3,1)
Ideea de demonstratie: Fie Bsolutie optima. Daca B = B si B are r
elemente comune cu B, se construieste o alta solutie optima B
din B a.i. B si B au r+1 elemente comune.
Secventializarea optima a activitatilor: model mat.
S = multimea activitatilor
C(S): X e C(S) daca X este solutie acceptabila (admite o
secventializare acceptabila)
proprietatea de alegere locala:
vezi slide-ul precedent
proprietatea de substructura optima:
daca i este prima activitate aleasa, atunci B-{i} este
solutie optima pentru subproblema obtinuta prin
eliminarea lui i
Algoritmi greedy formulare matematica
modelul matematic
S multime de stari, C colectie de submultimi ale lui S
axioma de accesibilitate (AA)
X e C: X = C (-x e X: X {x} e C)
sistem accesibil: (S, C)
X este extensibila daca exista y e S C a.i. X {y} e C
baza: X e C maximala
presupunere: B, B baze (B c B v B c B)
Algoritmi greedy formulare matematica (continuare I)
modelul matematic (continuare)
clasa de probleme:
intrare: S, C, f : C R (functia obiectiv)
iesire: o baza B cu f(B) = optim{f(X) | X baza in C}
alegere greedy: alege x dintre elementele nealese a.i.
f(B {x}) este optim peste
{f(B {y}) | y neales si (B {y}) e C} (*)

Algoritmi greedy formulare matematica (continuare II)
procedure algGreedy(S, C, f, B)
begin
S1 S
B C
while (B este extensibila) do
alege x din S1 conf. crit. (*)
S1 S1 {x}
B B {x}
end
Algoritmi greedy formulare matematica (continuare III)
un caz cind alegerea greedy produce optim global:
(S, C) este matroid:
AA este inlocuita cu proprietatea de ereditate:
X e C, X = C (x e X: X {x} e C)
are loc proprietatea de interschimbare (PI):
X, Y e C, |X| < |Y| (-y e Y-X: X {y} e C)
(S, C) este matroid ponderat:
f este o pondere: f : S R , f(X) = (f(x) | x e X)
optim = max
alegere greedy: alege x a.i.
f(x) = max{f(y) | y in S B, B {y}) e C}
Algoritmi greedy formulare matematica (continuare IV)
Teorema:
Algoritmul greedy determina o submultime optima daca
(S, C) este matroid ponderat.
Demonstratie:
x de pondere maxima
Fapt: exista o solutie optima B care contine pe x
fie B o solutie optima; pp ca x nu e in B
luam B ={x}; apoi utilizam PI si adaugam la B elem. din
B a.i. B = B {y} {x}
B este optima
S = { y | {x,y} e C }, C = {X | X {x} e C}
daca B este solutie pentru (S, C) care contine x, atunci B {x} este
solutie optima pentru (S, C)

Exemple de matroizi
S = multimea muchiilor dintr-un graf, C = mult. subgrafurilor aciclice
(reprezentate ca multimi de muchii)

C = multimea submultimilor de dim cel mult k

S = multimea coloanelor unei matrici n x n, C = multimea coloanelor
liniar independente