Gierige Algorithmen Interval Scheduling

Gierige Algorithmen Interval Scheduling IntervalScheduling(s,f). n length[s] 2. A {} 3. j 4. for i 2 to n do 5. if s[i] f[j] then 6. A A {i} 7. j i 8. return A

Gierige Algorithmen Interval Scheduling Beweisidee: Der gierige Algorithmus liegt vorn Wir messen Fortschritt des Algorithmus Schritt für Schritt Zeige: Der gierige Algorithmus macht mindestens genau so viel Fortschritt wie jeder beliebige andere Algorithmus Beobachtung: A ist eine Menge von kompatiblen Anfragen. 2

Gierige Algorithmen Interval Scheduling Wie können wir Optimalität zeigen? Sei O optimale Menge von Intervallen u. U. viele optimale Lösungen Wir zeigen: A = O 3

Gierige Algorithmen Interval Scheduling Wie können wir Optimalität zeigen? Sei O optimale Menge von Intervallen u. U. viele optimale Lösungen Wir zeigen: A = O 4

Gierige Algorithmen Interval Scheduling Notation: i,, i Intervalle von A in Ordnung des Hinzufügen j,, j Intervalle von O sortiert nach Endpunkt k m Zu zeigen: k = m i i 2 i 3 j j i 3 4 j 2 j 4 5

Gierige Algorithmen Interval Scheduling Der gierige Algorithmus liegt vorn: Idee des Algorithmus: Die Resource soll so früh wie möglich wieder frei werden Dies ist war für das erste Interval: f[i ] f[j ] Zu zeigen: Gilt für alle Intervalle i i 2 i 3 j j i 3 4 j 2 j 4 6

Gierige Algorithmen Interval Scheduling Lemma 8.4: Für alle r k gilt f[i r ] f[j ]. r i i 2 i 3 j j i 3 4 j 2 j 4 7

Gierige Algorithmen Interval Scheduling Lemma 8.4: Für alle r k gilt f[i r ] f[j ]. r f[i ], f[j ] i i 2 i 3 j j i 3 4 j 2 j 4 8

Gierige Algorithmen Interval Scheduling Lemma 8.4: Für alle r k gilt f[i r ] f[j ]. r f[i ] 2 i i 2 i 3 j j i 3 4 j 2 f[j ] 2 j 4 9

Gierige Algorithmen Interval Scheduling Lemma 8.4: Für alle r k gilt f[i r ] f[j ]. r f[i ] f[j ] 3 3 i i 2 i 3 j j i 3 4 j 2 j 4 0

Gierige Algorithmen Interval Scheduling Lemma 8.4: Für alle r k gilt f[i r ] f[j ]. r f[i ] 4 f[j ] i 4 i 2 i 3 j j i 3 4 j 2 j 4

Gierige Algorithmen Interval Scheduling Satz 8.5: Die von Algorithmus IntervalSchedule berechnete Lösung A ist optimal. i i 2 i 3 j j i 3 4 j 2 j 4 2

Gierige Algorithmen Interval Scheduling IntervalScheduling(s,f). n length[s] 2. A {} 3. j 4. for i 2 to n do 5. if s[i] f[j] then 6. A A {i} 7. j i 8. return A 3

Gierige Algorithmen Interval Scheduling IntervalScheduling(s,f). n length[s] 2. A {} Θ() 3. j 4. for i 2 to n do 5. if s[i] f[j] then 6. A A {i} 7. j i 8. return A 4

Gierige Algorithmen Interval Scheduling IntervalScheduling(s,f). n length[s] 2. A {} Θ() 3. j 4. for i 2 to n do 5. if s[i] f[j] then 6. A A {i} Θ(n) 7. j i 8. return A 5

Gierige Algorithmen Interval Scheduling IntervalScheduling(s,f). n length[s] 2. A {} Θ() 3. j 4. for i 2 to n do 5. if s[i] f[j] then 6. A A {i} Θ(n) 7. j i 8. return A Θ() 6

Gierige Algorithmen Interval Scheduling IntervalScheduling(s,f). n length[s] 2. A {} Θ() 3. j 4. for i 2 to n do 5. if s[i] f[j] then 6. A A {i} Θ(n) 7. j i 8. return A Θ() Θ(n) 7

Gierige Algorithmen Interval Scheduling Satz 8.6: Algorithmus IntervalSchedule berechnet in Θ(n) Zeit eine optimale Lösung, wenn die Eingabe nach Endzeit der Intervalle (rechter Endpunkt) sortiert ist. Die Sortierung kann in Θ(n log n) Zeit berechnet werden. 8

Berechne Lösung schrittweise In jedem Schritt mache lokal optimale Wahl Daumenregel: Wenn optimale Lösung eines Problems eine optimale Lösung von Teilproblemen enthält, dann gibt es häufig einen gierigen Algorithmus Algorithmen: Scheduling Probleme 9

Datenkompression Reduziert Größen von Files Viele Verfahren für unterschiedliche Anwendungen: MP3, MPEG, JPEG, Wie funktioniert Datenkompression? Zwei Typen von Kompression: Verlustbehaftete Kompression (Bilder, Musik, Filme, ) Verlustfreie Kompression (Programme, Texte, Excel-Dateien, ) 20

Datenkompression Reduziert Größen von Files Viele Verfahren für unterschiedliche Anwendungen: MP3, MPEG, JPEG, Wie funktioniert Datenkompression? Zwei Typen von Kompression: Verlustbehaftete Kompression (Bilder, Musik, Filme, ) Verlustfreie Kompression (Programme, Texte, Excel-Dateien, ) 2

Kodierung: Computer arbeiten auf Bits (Symbole 0 und ), nutzen also das Alphabet {0,} Menschen nutzen umfangreichere Alphabete (z.b. Alphabete von Sprachen) Darstellung auf Rechner erfordert Umwandlung in Bitfolgen 22

Beispiel: Alphabet Σ={a,b,c,d,,x,y,z,,.,:,!,?,&} (32 Zeichen) 5 Bits pro Symbol: 2 =32 Möglichkeiten 5 a b z. :!? & 00000 0000 00 00 0 00 0 0 23

Beispiel: Alphabet Σ={a,b,c,d,,x,y,z,,.,:,!,?,&} (32 Zeichen) 5 Bits pro Symbol: 2 =32 Möglichkeiten a b z. :!? & 00000 0000 00 00 0 00 0 0 Optimal? 5 4 Bits pro Symbol nicht genug Müssen im Durchschnitt 5 Bits für langen Text verwenden? 24

Beobachtung: Nicht jeder Buchstabe kommt gleich häufig vor Z.B. kommen x,y und z in Deutsch viel seltener vor als e,n oder r 25

Beobachtung: Nicht jeder Buchstabe kommt gleich häufig vor Z.B. kommen x,y und z in Deutsch viel seltener vor als e,n oder r Idee: Benutze kurze Bitstrings für Symbole die häufig vorkommen 26

Beobachtung: Nicht jeder Buchstabe kommt gleich häufig vor Z.B. kommen x,y und z in Deutsch viel seltener vor als e,n oder r Idee: Benutze kurze Bitstrings für Symbole die häufig vorkommen Effekt: Gesamtlänge der Kodierung einer Symbolfolge (eines Textes) wird reduziert 27

Grundlegendes Problem: Eingabe:Text in Alphabet Σ Gesucht: Eine binäre Kodierung von Σ, so dass die Länge des Textes in dieser Kodierung minimiert wird Beispiel: Σ={0,,2,,9} Text = 0025590004356789 (7 Zeichen) 0 2 3 4 5 6 7 8 9 0000 000 000 00 000 00 00 0 000 00 28

Grundlegendes Problem: Eingabe:Text in Alphabet Σ Gesucht: Eine binäre Kodierung von Σ, so dass die Länge des Textes in dieser Kodierung minimiert wird Beispiel: Länge der Kodierung: Σ={0,,2,,9} 4 7 = 68 Bits Text = 0025590004356789 (7 Zeichen) 0 2 3 4 5 6 7 8 9 0000 000 000 00 000 00 00 0 000 00 29

Grundlegendes Problem: Eingabe:Text in Alphabet Σ Gesucht: Eine binäre Kodierung von Σ, so dass die Länge des Textes in dieser Kodierung minimiert wird Beispiel: Σ={0,,2,,9} Text = 0025590004356789 (7 Zeichen) 0 2 3 4 5 6 7 8 9 0 000 00 00 0 0 00 0 0 30

Grundlegendes Problem: Eingabe:Text in Alphabet Σ Gesucht: Eine binäre Kodierung von Σ, so dass die Länge des Textes in dieser Kodierung minimiert wird Länge der Kodierung: Beispiel: 5 + 3 2 + 9 5 = 56 Bits Σ={0,,2,,9} Text = 0025590004356789 (7 Zeichen) 0 2 3 4 5 6 7 8 9 0 000 00 00 0 0 00 0 0 3

MorseCode: Elektrische Pulse über Kabel Punkte (kurze Pulse) Striche(Lange Pulse) Beispiele aus dem MorseCode: e ist 0 (ein einzelner Punkt) t ist (ein einzelner Strich) a ist 0 (Strich Punkt) Problem: Ist 00 eta, aa, etet, oder aet? 35

Problem Mehrdeutigkeit: Ist die Kodierung eines Buchstaben Präfix der Kodierung eines anderen Buchstaben, dann ist die Kodierung nicht immer eindeutig Beispiel: e = 0, a = 0 0 ist Präfix von 0 36

Präfix-Kodierung: Eine Präfix-Kodierung für ein Alphabet Σ ist eine Funktion γ, die jeden Buchstaben x Σ auf eine endliche Sequenz von 0 und abbildet, so dass für x,y Σ, x y, die Sequenz γ(x) nicht Präfix der Sequenz γ(y) ist. 37

Präfix-Kodierung: Eine Präfix-Kodierung für ein Alphabet Σ ist eine Funktion γ, die jeden Buchstaben x Σ auf eine endliche Sequenz von 0 und abbildet, so dass für x,y Σ, x y, die Sequenz γ(x) nicht Präfix der Sequenz γ(y) ist. Beispiel (Präfix-Kodierung): x Σ 0 2 3 4 5 6 7 8 9 γ(x) 00 000 00 0 00 00 0 0 0 38

Definition (Frequenz) Die Frequenz f[x] eines Buchstaben x Σ bezeichnet den Bruchteil der Buchstaben im Text, die x sind. Beispiel: Σ = {0,,2} Text = 00002200 f[0] = 3/5 f[] = /5 f[2] = /5 39

Definition (Kodierungslänge) Die Kodierungslänge eines Textes mit n Zeichen bzgl. einer Kodierung γ ist gegeben durch Beispiel: Kodierungslänge = Σ n f[x] γ(x) x Σ Σ = {a,b,c,d} γ(a) = 0; γ(b) =0; γ(c)= 0; γ(d)= Text = aacdaabb Kodierungslänge = 6 40

Definition (Kodierungslänge) Anzahl der Vorkommen von x im Die Kodierungslänge eines Textes mit n Text Zeichen bzgl. einer Kodierung γ ist gegeben durch Beispiel: Kodierungslänge = Σ n f[x] γ(x) x Σ Σ = {a,b,c,d} γ(a) = 0; γ(b) =0; γ(c)= 0; γ(d)= Text = aacdaabb Kodierungslänge = 6 4

Definition (Kodierungslänge) Länge Die Kodierungslänge eines Textes mit n Zeichen bzgl. der einer Kodierung γ ist gegeben durch Beispiel: Σ = {a,b,c,d} Kodierungslänge = Σ n f[x] γ(x) x Σ γ(a) = 0; γ(b) =0; γ(c)= 0; γ(d)= Text = aacdaabb Kodierungslänge = 6 Codierung von x 42

Definition (durchschn. Kodierungslänge) Die durchschnittliche Kodierungslänge eines Textes mit n Zeichen bzgl. einer Kodierung γ ist gegeben durch Beispiel: ABL(γ) = Σ f[x] γ(x) Σ = {a,b,c,d} γ(a) = 0; γ(b) =0; γ(c)= 0; γ(d)= Text = aacdaabb Durchschnittliche Kodierungslänge = 6/8 = 2 x Σ 43

Optimale Präfix-Kodierung: Problem: Optimale Präfix-Kodierung Eingabe: Alphabet Σ; für jedes x Σ seine Frequenz f[x] Ausgabe: Eine Kodierung γ, die ABL(γ) minimiert 44

Kodierungen und Binärbäume: a b d c 45

Kodierungen und Binärbäume: 0 0 b a 0 d c 46

Kodierungen und Binärbäume: a 0 d 0 x Σ γ(x) b a 00 b 0 c 0 c d 00 47

Kodierungen und Binärbäume: x Σ γ(x) a b 0 c 00 d 0 48

Kodierungen und Binärbäume: x Σ γ(x) a b 0 c 00 d 0 0 0 0 c b d a 49

Definition: Die Tiefe eines Baumknotens ist die Länge seines Pfades zur Wurzel. 0 0 b a 0 d c Tiefe(c) = 3 50

Neue Problemformulierung: Suche Binärbaum, dessen Blätter die Symbole aus Σ sind und der minimiert. ABL(T) = Σ f[x] Tiefe(x) x S 5

Definition: Ein Binärbaum heißt voll, wenn jeder innere Knoten zwei Kinder hat. 0 0 b a 0 d c Ein voller Binärbaum 52

Definition: Ein Binärbaum heißt voll, wenn jeder innere Knoten zwei Kinder hat. 0 0 b a d 0 Ein nicht voller Binärbaum, da der rote innere Knoten keine zwei Kinder hat 53

Lemma 6: Ein Binärbaum, der einer optimalen Präfix-Kodierung entspricht, ist voll. 0 b 0 d a 54

Lemma 6: Ein Binärbaum, der einer optimalen Präfix-Kodierung entspricht, ist voll. u d Beweis: 0 Annahme: T ist optimal und hat inneren Knoten u mit einem b Kind v Ersetze u durch v v Dies verkürzt die Tiefe einiger 0 Knoten, erhöht aber keine Tiefe Damit verbessert man die a Kodierung 55

Lemma 6: Ein Binärbaum, der einer optimalen Präfix-Kodierung entspricht, ist voll. d 0 v 0 a b Beweis: Annahme: T ist optimal und hat inneren Knoten u mit einem Kind v Ersetze u durch v Dies verkürzt die Tiefe einiger Knoten, erhöht aber keine Tiefe Damit verbessert man die Kodierung 56

Ein Gedankenexperiment: Angenommen, jemand gibt uns den optimalen Baum T*, aber nicht die Bezeichnung der Blätter Wie schwierig ist es, die Bezeichnungen zu finden? 57

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. 0 0 u y 0 v z 58

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. 0 0 0 x Σ f[x] a 0% b 2% c 8% d 60% 59

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. 0 0 d x Σ f[x] a 0% b 2% c 8% 0 d 60% 60

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. c 0 0 0 d x Σ f[x] a 0% b 2% c 8% d 60% 6

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. c 0 0 0 d x Σ f[x] a 0% b 2% c 8% d 60% b 62

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. c 0 0 0 d x Σ f[x] a 0% b 2% c 8% d 60% b a 63

Lemma 7: Seien u und v sind Blätter von T* mit Tiefe(u) <Tiefe(v). Seien u bzw. v in einer optimalen Kodierung mit y Σ bzw. z Σ bezeichnet. Dann gilt f[y] f[z]. c 0 0 0 d x Σ f[x] a 0% b 2% Anordnung innerhalb einer Tiefenstufe ist egal! c 8% d 60% a b 64

Beobachtung Sei v der tiefste Blattknoten in T*. Dann hat v einen Bruder und dieser ist ebenfalls ein Blattknoten. 0 0 d c 0 a w (Bruder von v) b v 65

Beobachtung Sei v der tiefste Blattknoten in T*. Dann hat v einen Bruder und dieser ist ebenfalls ein Blattknoten. c 0 0 0 d Beweis: Da ein optimaler Baum voll ist, hat v einen Bruder w Wäre w kein Blatt, dann hätte ein Nachfolger von w größere Tiefe als v a w (Bruder von v) b v 66

Zusammenfassende Behauptung Es gibt eine optimale Präfix-Kodierung mit zugehörigem Baum T*, so dass die beiden Blattknoten, denen die Symbole mit den kleinsten Frequenzen zugewiesen wurden, Bruderknoten in T* sind. 67

Zusammenfassende Behauptung Es gibt eine optimale Präfix-Kodierung mit zugehörigem Baum T*, so dass die beiden Blattknoten, denen die Symbole mit den kleinsten Frequenzen zugewiesen wurden, Bruderknoten in T* sind. 0 x Σ f[x] a 0% c 0 0 d b 2% c 8% d 60% a b 68

Behauptung Es gibt eine optimale Präfix-Kodierung mit zugehörigem Baum T*, so dass die beiden Blattknoten, denen die Symbole mit den kleinsten Frequenzen zugewiesen wurden, Bruderknoten in T* sind. c 0 0 0 d x Σ f[x] a 0% b 2% a und b erfüllen die Bedingungen der Behauptung! c 8% d 60% a b 69

Idee des Algorithmus: Die beiden Symbole y* und z* mit den niedrigsten Frequenzen sind Bruderknoten Fasse y* und z* zu einem neuen Symbol zusammen Löse das Problem für die übrigen n- Symbole (z.b. rekursiv) y* z* 70

Idee des Algorithmus: Die beiden Symbole y* und z* mit den niedrigsten Frequenzen sind Bruderknoten Fasse y* und z* zu einem neuen Symbol zusammen Löse das Problem für die übrigen n- Symbole (z.b. rekursiv) y*z* 7

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% d 0% 72

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% d 0% 73

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% d 0% Q: 23% 2% 55% 0% 74

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i= d 0% Q: 23% 2% 55% 0% 75

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i= d 0% Q: 23% 2% 55% x: 0% 76

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i= d 0% Q: 23% 55% x: y: 0% 2% 77

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i= d 0% Q: 23% 55% z: 22% 0% 2% 78

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i= d 0% Q: 23% 55% z: 22% 0% 2% 79

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i= d 0% Q: 23% 55% 22% 0% 2% 80

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i=2 d 0% Q: 23% 55% 22% 0% 2% 8

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i=2 d 0% Q: 23% 55% x: 22% 0% 2% 82

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) i=2 Q: 55% x Σ x: 22% y: 0% 2% f[x] a 23% b 2% c 55% d 0% 23% 83

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i=2 d 0% Q: 55% z: 22% 0% 2% 45% 23% 84

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i=2 d 0% Q: 55% z: 22% 0% 2% 45% 23% 85

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i=2 d 0% Q: 55% 45% 22% 23% 0% 2% 86

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) x Σ f[x] a 23% b 2% c 55% i=3 d 0% Q: 55% 45% 22% 23% 0% 2% 87

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) Q: x Σ f[x] a 23% b 2% c 55% i=3 d 0% 55% x: 22% 0% 2% 45% 23% 88

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) Q: i=3 x Σ f[x] a 23% b 2% c 55% d 0% x: y: 22% 0% 2% 45% 55% 23% 89

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) Q: z: i=3 22% 0% 2% x Σ f[x] a 23% b 2% c 55% d 0% 00% 45% 55% 23% 90

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) Q: z: i=3 22% 0% 2% x Σ f[x] a 23% b 2% c 55% d 0% 00% 45% 55% 23% 9

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) Q: i=3 22% 0% 2% x Σ f[x] a 23% b 2% c 55% d 0% 00% 45% 55% 23% 92

Huffmann(C). n C 2. Q C 3. for i to n- do 4. x Extract_Min(Q) 5. y Extract_Min(Q) 6. z new BinTree(x, f[x]+f[y],y) 7. f[z] f[x] + f[y] 8. Q Q {z} 9. return Extract_Min(Q) Q: i=3 22% 0% 2% x Σ f[x] a 23% b 2% c 55% d 0% 00% 45% 55% 23% 93

Satz 8 Algorithmus Huffman(C) berechnet eine optimale Präfix- Kodierung. 94

Gierige Algorithmen: Berechne Lösung schrittweise In jedem Schritt mache lokal optimale Wahl Anwendbar: Wenn optimale Lösung eines Problems optimale Lösung von Teilproblemen enthält Algorithmen: Scheduling Probleme Optimale Präfix-Kodierung (Huffman Codes) 95