Paradigma algoritmilor greedy

Prezentarea generala a paradigmei

Studii de caz
rucsac (varianta continua)
arbori Huffman
arbori partiali de cost minim
Algoritmi greedy modelul matematic
domeniul problemei
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 e C este extensibila daca exista y e S X a.i. X {y}
e C
baza: X e C maximala (nu mai poate fi extinsa)
B, B baze diferite (B c B v B c B)
Algoritmi greedy modelul matematic
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(locala): alege x dintre elementele
nealese a.i.
f(B {x}) este optim peste
{f(B {y}) | y neales si (B {y}) e C} (*)

trebuie demonstrat ca alegerile greedy (locale) conduc la
determinarea optimului global
Algoritmi greedy modelul matematic
schema de algorithm
greedy(S, C, f)
{
S1 = S;
B = C;
while (B este extensibila) {
alege x din S1 conf. crit. (*);
S1 = S1 {x};
B = B {x};
}
return B;
}
Algoritmi greedy modelul matematic
un caz cind alegerea greedy produce optim global:
(S, C) este matroid daca:
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 pentru matroizi
greedyMatroid(S, C, f)
{
S1 = S;
B = C;
while (B este extensibila) {
alege x din S1 conf. crit. (**);
S1 = S1 {x};
B = B {x};
}
return B;
}
Algoritmi greedy modelul matematic
Teorema:
Algoritmul greedyMatroid determina o submultime
optima daca (S, C) este matroid ponderat.
Demonstratie:
fie 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 (pe tabla)
S = { y | {x,y} e C }, C = {X | X {x} e C}
(S, C) matroid
daca B este solutie pentru (S, C) care contine x, atunci B {x} este
solutie optima pentru (S, C)

Studii de caz
rucsac (varianta continua)
arbori Huffman
arbori partiali de cost minim

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
partile fractionare alese trebuie sa incapa in rucsac

i=0,n-1
x
i
w
i
s M

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: domeniul problemei
S = {(i,x
i
) | 0 s i < n, x
i
e [0,1]}
X e C daca:
((i,x
i
), (i,x
i
) e X) i = i x
i
= x
i

(x
i
w
i
| (i,x
i
) e X) s M
are loc proprietatea de ereditate
X e C , (i, x
i
) e X implica X {(i, x
i
)} e C
nu are proprietatea de interschimbare (deci nu se poate aplica
teorema de la matroizi)
w = (7, 4, 5), M = 10, X = {(0, 1), Y = {(1, 1), (2, 1)}
|X| = 1, |Y| = 2, dar nu exista (i, y) e Y a.i. X {(i, y)} e C
f(i, x
i
) = x
i
p
i

f(X) = (f(i, x
i
) | (i, x
i
) e X)

Problema rucsacului: alegeri greedy
alegere 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)
alegerea greedy OK:
(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
)}
exemplu (continuare):
p/w = (3/6, 4/4, 6/8)
profitul = 17/2 cu alegerea (0, 1, 6/8)
Problema rucsacului: algoritmul greedy
greedyRucsac(n, w, p, M)
{
S1 = {0,1,, n-1};
B = C; wB = 0;
while (wB < M) {
alege i din S1 cu p
i
/w
i
maxim;
S1 = S1 {i};
x
i
= min(M wB, 1);
B = B {(i,x
i
)};
wB += x
i
;
}
return B;
}

Problema rucsacului: analiza algoritmului greedy OK

Teorema Solutia calculata de algoritmul greedyRucsac este
optima
demonstratie (pe tabla)

timpul de executie in cazul cel mai nefavorabil: O(n log n)
spatiu suplimentar: O(n)
Studii de caz
rucsac (varianta continua)
arbori Huffman
arbori partiali de cost minim

Coduri Huffman
Coduri liber (independent) de prefix optime
instanta
n mesaje M
0
, M
1
, ..., M
n-1
cu frecventele w
0
, w
1
, ..., w
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
)|w
i
)

iesire
o codificare cu lungimea medie minima
Coduri Huffman: istoric
Din wikipedia:
In 1951, David A. Huffman and his MIT information theory
classmates were given the choice of a term paper or a final
exam. The professor, Robert M. Fano, assigned a term paper on
the problem of finding the most efficient binary code. Huffman,
unable to prove any codes were the most efficient, was about to
give up and start studying for the final when he hit upon the idea
of using a frequency-sorted binary tree and quickly proved this
method the most efficient.

In doing so, the student outdid his professor, who had worked with
information theory inventor Claude Shannon to develop a
similar code. By building the tree from the bottom up instead of
the top down, Huffman avoided the major flaw of the
suboptimal Shannon-Fano coding.
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
w
i
1 4 2 2 1
cod(M
i
) 0010 011 010 10 110
Coduri Huffman: reprezentarea unei codificari ca arbore
deoarece ne intereseaza numai codificarile optime, ne putem
restrange numai la arbori in care nodurile interne au exact doi
copii (se face o compactare a drumurilor)
1
2
4
1 2
0
0
1
0
1
1
1
0
H
R
A
B
U
Echivalenta cu arbori ponderati pe frontiera minimali
Consideram arbori binari cu proprietatea ca orice varf v are
0 sau 2 succesori si care au ca informa tii (etichete, ponderi)
in varfurile de pe frontiera numere w
v
. Convenim sa
numim acesti arbori ca fiind ponderati pe frontiera.
Pentru un varf v din arborele T notam cu d
v
lungimea
drumului de la radacina lui T la varful v. Lungimea externa
ponderata a arborelui t este
LEP(T)=
v pe frontiera lui t
d
v
w
v

problema determinarii unei codificari de lungime medie
minima este echivalenta cu cea a determinarii unui arbore
cu lungimea externa ponderata minima pentru ponderile w
date de frecvente.

Arbori ponderati pe frontiera: domeniul problemei
S cea mai mica multime de arbori construita astfel:
w
i
e S pentru orice i
T
1
, T
2
e S T
1
T
2
e S









S include toti arborii ponderati pe frontiera cu valori w
i

S include toti arborii optimi (care au lungimea externa ponderata
minima pentru o secventa w data)
n
1

n
2

n
1

n
2

n
1
+ n
2

T
1
T
2
T
1
T
2
Arbori ponderati pe frontiera: domeniul problemei
X e C daca:
( T
1
, T
2
e X) ( T
1
T
2
|| T
2
T
1
), unde T
1
T
2
ddaca
exista T a. i. T
2
= T
1
T


X este finita
X

e C include numai elemente -maximale
f(T) = LEP(T)
f(X) =
T e X
f(T)
Arbori ponderati pe frontiera: domeniul problemei
are loc axioma de accesibilitate (de ce?) (S, C) sistem
accesibil
nu are loc proprietatea de ereditate (contraexemplu) nu se
poate aplica teorema de la matroizi
ce se poate spune despre proprietatea de interschimbare?
Coduri Huffman: alegere greedy
initial: B = { w
0
, , w
n-1
}
alegere locala
alege T
1
, T
2
cu radacini minime in B si T
1
T
2
nu este in B
B = B {T
1
, T
2
} {T
1
T
2
}
(nu mai e nevoie de S1, ea poate fi calculata)

arborii construiti cu algoritmul greedy se numesc si arbori
Huffman (ei definesc codurile Huffman)


Proprietati ale codurilor Huffman
Lema
Fie T un arbore optim, v si v doua noduri pe frontiera lui T.
Daca w
v
< w
v
atunci d
v
> d
v.

Interpretarea pentru coduri optimale: mesajele cu frecvente mai
mari au lungimile codurilor optime mai mici

demonstratie (pe tabla)
Lema
Orice arbore optim poate fi transformat intr-un arbore
Huffman.

demonstratie (pe tabla)
Coduri Huffman: algoritm greedy
greedyArbPondFr(w)
{
B = C;
for (i=0; i<n; ++i)
B = B {single(w
i
)};
while (|B| > 1) {
alege T
1
, T
2
din B cu root(T
1
)si root(T
2
)
minime;
B = B {T
1
, T
2
} } {T
1
T
2
};
}
return B;
}

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
timpul de executie in cazul cel mai nefavorabil: 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
. . .
w
Studii de caz
rucsac (varianta continua)
arbori Huffman
arbori partiali de cost minim

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
Domeniul problemei generic
S = multimea de muchii E
X e C daca X e submultime de muchii a unui arbore partial
f(X) = suma ponderilor muchiilor din X (este functie de pondere)
Alegere greedy generica
muchia {i,j} este sigura pentru B B {{i,j}}este
submultime a unui arbore partial de cost minim

deocamdata pare magic cum putem alege o muchie sigura fara
sa cunoastem un arbore partial de cost minim (daca am sti un
astfel de arbore, problema ar fi rezolvata!)
Arborele partial de cost minim algoritm generic
procedure APCM(G, w)
begin
B = C;
S1 = E;
while ((V, B) nu este arbore partial) do
alege din S1 o muchie {i,j} sigura pentru B;
S1 = S1 - {{i,j}};
B = B {{i,j}};
end
Arborele partial de cost minim algoritmul lui Kruskal
X e C daca X este padure
(S, C) este matroid, deci se poate aplica teorema de la matroizi
rezulta ca {i,j} e sigura pentru B ddaca w({i,j}) este minim
peste muchiile care unesc doi arbori din B
20
10
40
30
10
30
20
50
20
10
10
30
Arborele partial de cost minim algoritmul lui Kruskal (cont)
structura de date pentru B: union-find, S1 nu mai e necesara
kruskal(G, w)
{
B = C;
for each (i in V) B = B {single(i)};
sorteaza E crescator dupa w;
for each {i,j} in E in ordine crescatoare
if (find(B, i) = find(B, j)
union(B, i, j);
return B
}
Complexitate: O(m log m), unde m este numarul de muchii
Arborele partial de cost minim algoritmul lui Prim
X e C daca X este arbore
{i,j} e sigura pentru B ddaca w({i,j}) este minim peste muchiile
care se pot adauga la B mentinind proprietatea de arbore
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) {
Q = V;
for each i in Q key[i] = ;
cheie[r] = 0; parent[r] = -1;
while (Q = C) {
i = Q.read(); Q.pop();
for each j in G.a[i])
if (j e Q && w({i,j}) < key[j]) {
parent[j] = i;
key[j] = w({i,j});
}
}
return parent;
}
Algoritmul lui Prim - analiza
structura de data pentru S1: un min-heap Q cu key[i] = ponderea
minima peste ponderile muchiilor ce unesc pe i cu un virf ales
deja

structura de date pentru B: arbore reprezentat prin legatura parinte

graful reprezentat prin liste de adiacenta G.a[i]

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