Teil 4: Algorithmen-Entwurfstechniken Idee der Greedy-Algorithmen ...

Idee der Greedy-Algorithmen 

Teil 4: 

Algorithmen-Entwurfstechniken 

• Greedy-Algorithmen 

– Idee 

– Job Scheduling 

– Datenkompression mit dem Huffman-Verfahren 

– Bin Packing 

• Teile-und-Herrsche-Verfahren 

• Dynamisches Programmieren 

Idee: 

• Löse ein Problem, indem mit einer einfachen Teillösung begonnen und diese 

schrittweise erweitert wird. 

• Wähle dabei immer den bestmöglichen Schritt, 

ohne Berücksichtigung zukünftiger Schritte: 

„Nimm immer das größte Stück zuerst“; greedy = gierig, gefräßig. 

Algorithmen-Schema: 

while (Problem nicht gelöst) 

{ 

wähle bestmöglichen Schritt s nach einer greedy-Strategie; 

baue Schritt in Lösung ein; 

} 

Greedy-Schritt 

Beispiele für Greedy-Algorithmen: 

• Kürzeste Wege in gewichteten Graphen mit dem Algorithmus von Dijkstra 

• Minimal aufspannender Baum mit dem Algorithmus von Kruskal 

• Minimal aufspannender Baum mit dem Algorithmus von Prim 

O. Bittel; Juli 2007 Algorithmen und Datenstrukturen - Algorithmen-Entwurfstechniken 4-1 


Wechselgeld-Algorithmus 

Problem: 

Gib einen Betrag in Euro mit möglichst wenig Münzen und Scheinen heraus. 

Beispiel: 17,69 € = 10 € + 5 € + 2 € + 50 Ct + 10 Ct + 5 Ct + 2 Ct + 2 Ct 

Greedy-Algorithmus: 

void wechselgeld(double betrag) 

{ 

herausgegeben = 0; 

while (herausgegeben < betrag) 

Greedy-Schritt 

{ 

wähle größtmögliche Münze bzw. Schein s mit herausgegeben + s ≤ betrag; 

cout

Job-Scheduling für Multiprozessorssysteme (1) 

Problem: 

Gegeben seinen n Jobs 

j 1 , j 2 , …, j n 

mit den Ausführungszeiten 

t 1 , t 2 , …, t n 

Die Jobs sollen p Prozessoren so zugeteilt werden, dass eine bestimmte 

Zielfunktion minimiert wird: 

(1) Minimiere durchschnittliche Abschlusszeit, 

wobei: Abschlusszeit für Job = Wartezeit + Ausführungszeit. 

(2) Minimiere gesamte Abschlusszeit: 

d.h. Zeit, in der alle Jobs abgeschlossen sind 

Greedy-Algorithmus: Shortest-Job-First 

Wähle einen noch nicht bedienten Job mit kürzester Ausführungszeit und teile ihn 

demjenigen Prozessor zu, der als nächster einen Job bedienen kann. 



Beispiel: 

Job 

Zeit 

j 1 

3 

j 2 

5 

j 3 

j 4 

6 

j 5 

10 

j 6 

11 

j 7 

14 

j 8 

15 

18 

j 9 

20 

j 1 

j 2 

j 3 

j 4 

j 5 

j 6 

j 7 

j 8 

j 9 

6 20 40 

Zuteilung der Jobs an 3 Prozessoren mit 

dem Shortest-Job-First-Algorithmus 

Minimierung der durchschnittlichen Abschlusszeit 

Der Shortest-Job-First-Algorithmus liefert immer eine optimale Lösung. 

Begründung: 

Im Beispiel ist die durchschnittliche Abschlusszeit: 

[ t 1 + t 2 + t 3 + (t 1 +t 4 ) + (t 2 +t 5 ) + (t 3 +t 6 ) + (t 1 +t 4 +t 7 ) + (t 2 +t 5 +t 8 ) + (t 3 +t 6 +t 9 ) ] / 9 

= [ 3t 1 +3t 2 +3t +2t 3 4 +2t 5 +2t 6 + t 7 + t 8 + t 9 ] / 9 

Dieser Wert ist minimal, wenn t 1 ,t 2 ,t ≤ t 3 4 ,t 5 ,t 6 ≤ t 7 ,t 8, t 9 . 

Das wird jedoch vom Algorithmus gewährleistet. 



Minimierung der gesamten Abschlusszeit 

Der Shortest-Job-First-Algorithmus liefert im allgemeinen nur eine suboptimale Lösung. 

Im Beispiel ist die gesamte Abschlusszeit = 40. 

Folgendes Lösung zeigt, dass auch eine gesamte Abschlusszeit 

von 34 erreicht werden kann. 



j 1 

j 3 

j 4 

j 7 

j 2 j 5 

j 8 

j 6 

j 9 

14 34 

Das Problem der Minimierung der gesamten Abschlusszeit beim Job-Scheduling 

ist NP-vollständig. 

Für NP-vollständige Probleme sind zur Zeit nur exponentielle Verfahren (d.h. O(2 n )) 

bekannt. 

Es ist ein bisher berühmtes ungelöstes Problem in der Informatik, ob es für 

NP-vollständige Probleme schnellere Verfahren gibt (d.h. polynomielle Vefahren O(n k )). 

Viele Indizien sprechen dafür, dass es für NP-vollständige Probleme keine schnelleren 

Verfahren gibt. 









O. Bittel; Juli 2007 Algorithmen und Datenstrukturen - Algorithmen-Entwurfstechniken 4-8

Datenkompression (1) 

Problem: 

Gegeben ist ein Text t als Folge von ASCII-Zeichen, 

deren Häufigkeiten im Text bekannt sind. 

Beispiel: 


Codebäume: 

Wir wollen uns hier auf binäre Codierung der Einzelzeichen einschränken, 

wobei sich der Binärcode in einem Code-Baum darstellen lässt. 

Wichtig: Zu codierende Zeichen sind die Blätter des Code-Baums. 

Zeichen 

a 

e 

Häufigkeit 

10 

15 

Beispiele: 

nl 

i 

s 

12 

3 

a e i s t sp nl 

a e i s 

t 

sp 

t 

4 

Zeichen 

Code 

Zeichen 

Code 

space 

newline 

13 

1 

a 

e 

i 

000 

001 

010 

a 

e 

i 

0000 

0001 

0010 

Gesucht ist eine möglichst kurze binäre Codierung des Textes t. 

Selbstverständlich sollte der codierte Text auch wieder decodierbar sein. 

s 

t 

sp 

nl 

011 

100 

101 

110 

s 

t 

sp 

nl 

0011 

010 

011 

1 

Binärcode mit 

konstanter Bitlänge 

Binärcode mit 

variabler Bitlänge 




Fano-Bedingung: 

Ein Code erfüllt die Fano-Bedingung, falls keine Codierung eines Zeichens Präfix 

(Anfangstück) einer Codierung eines anderen Zeichen ist. 

Durch Code-Bäume dargestellte Bäume erfüllen immer die Fano-Bedingung. 

Codes, die Fano-Bedingung erfüllen, sind eindeutig decodierbar. 

Beispiel: 

Decodieren Sie folgende Binärfolge mit dem unten gegebenen Binärcode: 

0010110110100010 


Algorithmus von Huffman: 

• Idee: 

Verwende einen Binärcode variabler Länge, wobei häufigere Zeichen kürzere 

Codierungen erhalten. 

• Verfahren: 

(1) Beginne mit einem Wald von Code-Bäumen, 

wobei jeder Baum anfangs aus genau einem Zeichen besteht. 

Jeder Baum besitzt außerdem ein Gewicht w, das gleich der Summe der 

Häufigkeiten der Zeichen im Baum ist. 

nl 

Zeichen 

a 

Code 

0000 

(2) Greedy-Schritt: 

Wähle die beiden Bäume t 1 

und t 2 

mit den kleinsten Gewichten w 1 

und w 2 

und bilde daraus einen neuen Baum mit dem Gewicht w = w 1 

+ w 2 

: 

a e i s 

t 

sp 

e 

i 

s 

0001 

0010 

0011 

t 1 

t 2 

t 

010 

sp 

nl 

011 

1 

(3) Wiederhole Schritt (2) solange, bis nur noch ein Baum vorhanden ist. 

Dieser Baum ist dann der gesuchte optimale Binärcode. 





Beispiel: 

Zeichen Häufigkeit 

a 

e 

i 

s 

t 

sp 

nl 

10 

15 

12 

3 

4 

13 

1 

Schritt (1): 

Wald von Bäumen mit jeweils genau einem Zeichen und Häufigkeiten als Gewichte (blau) 

Beispiel (Fortsetzung): 

c) 

d) 

10 15 12 13 

a e i sp 

15 12 13 

e i sp 

s 

nl 

t 

s 

18 

a 

8 

nl 

t 

f) 

g) 

i 

25 

sp 

s 

nl 

58 

33 

e 

a 

t 

a) 

10 15 12 3 4 13 1 

a e i s t sp nl 

Schritt (2) wiederholt angewendet: 

Baue die beiden Bäume mit geringstem Gewicht zu einem Baum zusammen. 

b) 

10 15 12 4 13 4 

a e i t sp 

s nl 

e) 

15 

e 

i 

25 

sp 

s 

nl 

18 

t 

a 

s 

nl 

t 

e 

a 

Fertig! 

i 

sp 



Beispiel (Fortsetzung): 

Optimaler Code: 

s 

nl 

t 

e 

a 

58 


i 

sp 

Zeichen Häufigkeit 

a 

e 

i 

s 

t 

sp 

nl 


10 

15 

12 

3 

4 

13 

1 

Code 

001 

01 

10 

00000 

0001 

11 

00001 

Bemerkung: 

Verwendet man den optimalen Code, dann benötigt man für die oben 

angegebenen Häufigkeiten: 

10*3 + 15*2 + 12*2 + 3*5 + 4*4 + 13*2 + 1*5 = 146 Bit 

Damit benötigt man 146/58 = 2.5 Bit/Zeichen 

Im Vergleich dazu benötigt man beim Bitcode mit konstanter Bitlänge 3 Bit/Zeichen. 

Bemerkungen 


• Die Häufigkeitsanalyse kann auch einmalig (statisch) erfolgen. 

Beispielsweise kommt in typisch deutschen Texten der Buchstabe ‚e‘ (ohne 

Berücksichtigung von Groß- und Kleinschreibung) mit der Häufigkeit 0.175 vor. 

Nimmt man einen Code mit konstanter Bitlänge, dann benötigt man ⎣log 2 26⎦ = 5 

Bit/Zeichen. Mit einer Huffman-Codierung erhält man etwa 4.1 Bit/Zeichen. 

Verbessern lässt sich das Verfahren, indem Buchstabenpaare oder noch längere 

Buchstabenfolgen betrachtet werden. Bei Buchstabenpaaren erreicht man etwa 3.5 

Bit/Zeichen. 

• Das Huffman-Verfahren gehört zu der Klasse der statistikbasierten 

Kompressionsverfahren. Kritisch bei diesen Verfahren ist die Erstellung einer 

Häufigkeitstabelle, insbesondere wenn längere Buchstabenfolgen berücksichtigt 

werden und die Erstellung der Tabelle dynamisch erfolgen soll. 

Dagegen werden bei den wörterbuchbasierten Verfahren bereits komprimierte 

Zeichenfolgen in einem Wörterbuch gehalten und beim wiederholten Auftreten in der 

codierten Zeichenfolge lediglich ein Verweis auf den Tabelleneintrag abgespeichert. 

Diese Verfahren gehen auf Lempel und Ziv zurück. Alle Abkömmlinge dieses 

Verfahrens werden daher mit LZxxx bezeichnet. Beispielsweise wird eine Kombination 

von LZ77 und dem Huffman-Verfahren in den Kompressionsprogrammen Zip und Gzip 

eingesetzt. 


Bin Packing - Problemstellung 










Problem: 

Gegeben seien n Gegenstände mit den Größen 

s 1 , s 2 , …, s n , 

wobei 0 < s i ≤ 1. 

Gesucht ist eine möglichste geringe Zahl von Behältern (bins) mit Größe 1, 

so dass alle Gegenstände untergebracht werden können. 

Aproximative Algorithmen 

Da Bin Packing NP-vollständig ist, kann nicht erwartet werden, dass es ein effizientes 

Verfahren zum Finden einer optimalen Lösung gibt. 

Wir werden effiziente Greedy-Algorithmen behandeln, die nur suboptimale Lösung liefern, 

d.h. die die optimale Lösung wird approximiert. 

Online- und Offline-Algorithmen 

Bei Online-Algorithmen muss der Algorithmus einen Gegenstand sofort einem Behälter 

zuordnen, ohne die nächsten Gegenstände zu kennen. 

Bei den Offline-Algorithmen kennt der Algorithmus alle Gegenstände im voraus. 



Online Bin Packing (1) 

Next Fit: 

Verwalte die Behälter in einer festen Reihenfolge. 

Gehe vom zuletzt verwendeten Behälter (einschl.) aus und 

ordne den Gegenstand i dem nächst besten Behälter zu, in dem i noch Platz hat. 

Beispiel 

Gegenstände: 0.2, 0.5, 0.4, 0.7, 0.1, 0.3, 0.8 

leer 

0.5 

0.2 

B 1 

leer 

0.1 

0.7 

B 3 

leer 

0.8 

leer 

leer 

0.4 

0.3 

Eigenschaft 

Sei m die optimale Anzahl Behälter, um n Gegenstände einzupacken. 

Dann benötigt Next Fit maximal 2m Behälter. 

Es gibt eine Folge von Gegenstände, so dass Next Fit 2m-2 Behälter benötigt. 

(Beweis siehe [Weiss 1999]) 


B 5 


First Fit: 

Verwalte die Behälter in einer festen Reihenfolge. 

Gehe immer vom ersten Behälter aus und 

ordne den Gegenstand i dem erst besten Behälter zu, in dem i noch Platz hat. 

Beispiel 

Gegenstände: 0.2, 0.5, 0.4, 0.7, 0.1, 0.3, 0.8 

leer 

0.1 

0.5 

leer 

0.3 

0.4 

0.2 

B 1 

B 2 

leer 

0.7 

B 3 

leer 

0.8 

B 4 

Eigenschaft 

Sei m die optimale Anzahl Behälter, um n Gegenstände einzupacken. 

Dann benötigt First Fit maximal ⎡(17/10)m⎤ Behälter. 

Es gibt eine Folge von Gegenstände, so dass First Fit (17/10)(m-1) Behälter benötigt. 




Best Fit 

Ordne einen Gegenstand i immer demjenigen Behälter mit dem kleinsten verfügbaren 

Platz zu, in dem i noch Platz hat. Man wählt also den am besten passenden Behälter. 

Beispiel 

Gegenstände: 0.2, 0.5, 0.4, 0.7, 0.1, 0.3, 0.8 

leer 

0.1 

0.5 

leer 

0.4 

0.2 

B 1 

B 2 

0.3 

0.7 

B 3 

leer 

0.8 

B 4 

Eigenschaft 

Best Fit hat den gleichen Worst Case wie First Fit. Jedoch ist eine kleine mittlere Behälter- 

Anzahl als bei First Fit zu erwarten. 


Offline Bin Packing (1) 

First Fit Decreasing 

Sortiere die Gegenstände ihrer Größe nach absteigend und 

teile dann die Gegenstände nach der First-Fit-Strategie zu. 

Best Fit Decreasing 

Sortiere die Gegenstände ihrer Größe nach absteigend und 

teile dann die Gegenstände nach der Best-Fit-Strategie zu. 

Beispiel für First Fit Decreasing 

Gegenstände: 0.2, 0.5, 0.4, 0.7, 0.1, 0.3, 0.8 

0.2 

0.3 

0.4 

0.8 

0.7 

0.5 

B 1 

B 3 

B 2 

0.1 

Algorithmus liefert optimale Lösung! 



Offline Bin Packing (2) 

Eigenschaft 

• Sei m die optimale Anzahl Behälter, um n Gegenstände einzupacken. 

Dann benötigt First Fit Decreasing maximal ⎡(11/9)m + 4⎤ Behälter. 

Es gibt eine Folge von Gegenstände, so dass First Fit Decreasing ⎡(11/9)m⎤ Behälter 

benötigt. 

• Sind die Größen der Genestände im Interval [0,1] gleichverteilt, dann benötigt First Fit 

Decreasing im Schnitt O(√m) Behälter mehr als die optimale Lösung. 

• Die Eigenschaften für Best Fit Decreasing sind fast identisch.

Teil 4: Algorithmen-Entwurfstechniken Idee der Greedy-Algorithmen ...

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?