Algorithmen und Datenstrukturen

Algorithmen und 

Datenstrukturen 

Kapitel 7: 

Algorithmenkonstruktion II 

Sommersemester 2007 

Prof. Dr. Stefan Fischer

Inhalt 

� Dynamische Programmierung 

� Verteilte Berechnungen 

� Zufallsgesteuerte Algorithmen 

2/47

Dynamische Programmierung 

� Grundprinzip 

� Beispiel: Fibonacci-Zahlen 

� Das Rucksack-Problem 

� Textsuche (Vorberechnung) 

3/47

Grundprinzip 

� Rekursive Lösungsstruktur: 

1. Aufteilung in abhängige Teilprobleme (Ggs: Teile-und-Herrsche 

mit unabhängigen Teilproblemen) 

2. Berechnen und Zwischenspeichern wiederkehrender 

Teilergebnisse 

3. Bestimmung des Gesamtergebnisses unter Verwendung der 

Teilergebnisse 

� Häufig verwendet bei Optimierungsproblemen: 

� Interpretation der Teilergebnisse als optimale Lösung eines 

"kleineren" Teilproblems 

� Ggf. zusätzlicher Schritt 4: Konstruktion der optimalen Lösung auf 

Basis der berechneten Teillösungen. 

Dabei ggf. Hinzuziehung weiterer Informationen aus Schritt 3. 

4/47

Beispiel (1/2) 

Beispiel Fibonacci-Zahlen: 

fib:IN 0 →IN mit 

fib(0) = 0 

fib(1) = 1 

n > 1: fib(n) = fib(n-1) + fib(n-2) 

Analoge Rekursive Lösung 

in Java Pseudocode: 

public int fibRek(int n) { 

if (n = 0) return 0; 


return fibRek(n-1)+fibRek(n-2); 

} 

Berechnung wiederholt 

bestimmte Schritte: 

fib(2) = fib(1) + fib(0) 

fib(3) = fib(2) + fib(1) 

fib(4) = fib(3) + fib(2) ... 

Aufwandsabschätzung: 

T(n) = Anzahl Additionen 

T(0) = 0 

T(1) = 0 

T(n) = 1+T(n-1)+T(n-2) für n≥2 

=> Rekursive Lösung ist teuer! 

Es geht billiger mit dynamischer Programmierung. 

5/47

Beispiel (2/2) 

Iterative dynamische Lösung in Java Pseudocode: 

public int fibDynPro(int n) { 

int result; 



int fibMinus1 = 1, fibMinus2 = 0; 

for(int i=2; i

Das Rucksack-Problem (1/8) 

� Die Story: 

� Schatzsucher findet Schatz bestehend aus Edelsteinen. 

� Jeder Edelstein hat 

- ein bestimmtes Gewicht und 

- einen bestimmten Wert. 

� Er hat nur einen Rucksack, dessen Kapazität durch ein maximales 

Gewicht gegeben ist. 

� Die Aufgabe: befülle den Rucksack mit Edelsteinen 

� ohne die Gewichtsbeschränkung zu verletzen 

� bei Maximierung des Wertes der Edelsteine. 

7/47 

x kg y € 

≤ z kg


� Formale Fassung des Rucksack-Problems (engl. Knapsack-P.): 

� Gegeben 

� Kapazität c ∈ IN 

� Menge O mit n∈ IN Objekten o 1 , o 2 ,..., o n 

� Gewichtsfunktion g:O→IN 

� Bewertungsfunktion w: O→IN 

� Gesucht ist O’⊆ O mit 

Dabei gelte ∑ 

j∈ 

O 

g ( j) 

> 

c 

∑ 

j∈O' 

g( j) 

≤ c und w( 

j) 

maximal 

∑ 

j∈O' 

Anmerkung: Eigtl. 0-1 Knapsack Problem, da nur ganze Objekte 

betrachtet werden dürfen (ansonsten Fractional Knapsack Problem). 

8/47


� Erste Lösungsidee: Greedy 

� Aber: Greedy funktioniert nicht! 

� Beispiel: O = { o 1, o 2, o 3 }, Kapazität c = 5 

� Gewichte: g(o 1 ) = 1, g(o 2 ) = 2, g(o 3 ) = 3 

� Werte: w(o 1 ) = 6, w(o 2 ) = 10, w(o 3 ) = 12 

� Greedy: Nimm Objekt mit größtem relativen Wert bis Rucksack voll! 

� Relative Werte ( r(o)=w(o)/g(o) ): r(o 1) = 6, r(o 2) = 5, r(o 3) = 4 

� Ergebnis: O’={o 1, o 2}, mit 

∑ 

j∈O' 

sicher nicht maximal! 

Besser ist O’’={o3 , o2 } m.∑ 

j∈ 

g( j) 

= 3 < c = 5 und 

O'' 

∑ ∈O 

j 

' 

w( 

j) 

= 16 

∑ 

j∈O'' 

g( j) 

= 5 ≤ c = 5 u. w( 

j) 

= 22 

9/47


� Zweite Lösungsidee: Backtracking 

� Funktioniert, ist aber aufwändig! 

� Beispiel: O = { o 1, o 2, o 3 , o 4 }, c = 10 

� Gewichte: g(o 1 ) = 2, g(o 2 ) = 2, g(o 3 ) = 6, g(o 4 ) = 5 

� Werte: w(o 1 ) = 6, w(o 2 ) = 3, w(o 3 ) = 5, w(o 4 ) = 4 

� Lösungsraum 

(Konfigurations- 

baum): 

10 8 

8 

6 

(0,0) (5,4) (6,5) (2,3) (7,7) (8,8) (2,6) (7,10) (8,11) (4,9) (9,13) (10,14) 

10/47 

Zur Disposition: 

o :(g,w) 

10 4 8 2 8 2 6 0 

10 5 4 8 3 2 8 3 2 6 1 0 

*Restkapazität 

10* 

nein 

ja 

10 8 

Teilbäume gleich 

> Optimierungspotenzial 

> Dyn. Prog 

o 1 :(2,6) 

o 2 :(2,3) 

o 3 :(6,5) 

o 4 :(5,4)


Rekursive Backtracking-Lösung in Java Pseudocode: 

public int btKnapsack(int i, int restkapazität ) { // Aufruf: btKnapsack(1,c) 

// Rückgabewert: Wert d. optimalen Füllung bei O={oi,...,on} und 

c=restkapazität 

Objekt o=objekte[i]; // objekte[] ist globale Variable mit Indexmenge {1,2,....,n} 

if ( i==objekte.length ) // Ende der Rekursion: o ist das letzte Objekt 

if (o.gewicht() > restkapazität) // wenn o nicht mehr hinein passt, dann 

return 0; // bleibt es draußen 

else return o.wert(); // andernfalls kommt es hinein und steigert den Wert 

else if (o.gewicht() > restkapazität) // analog bei den anderen Objekten 

return btKnapsack(i+1, restkapazität) 

else return max( btKnapsack(i+1,restkapazität), 

btKnapsack(i+1,restkapazität–o.gewicht())+o.wert() ); // 

Wenn es noch hinein passt, werden dennoch 

} // beide Möglichkeiten betrachtet 

Anmerkung: Optimierungspotenzial (Ausnutzen wiederkehrender Berechnungen) 

wird hier nicht genutzt! 

11/47


� Lösung durch dynamische Programmierung 

� Beispiel: O = { o 1 , o 2 , o 3 , o 4 , o 5 }, c = 10 

� Gewichte: g(o 1 ) = 2, g(o 2 ) = 2, g(o 3 ) = 6, g(o 4 ) = 5, g(o 5 ) = 4 

� Werte: w(o 1 ) = 6, w(o 2 ) = 3, w(o 3 ) = 5, w(o 4 ) = 4 , w(o 5 ) = 6 

� Idee: In Iteration rückwärts die Resultate der Aufrufe btKnapsack(i,r) 

berechnen > Verwendung eines zweidimensionalen Feldes f: 

i 

r 

0 1 2 3 4 5 6 7 8 9 10 

5 0 0 0 0 6 6 6 6 6 6 

4 0 0 0 0 6 6 6 6 6 10 10 

3 0 0 0 0 6 6 6 6 6 10 11 

2 0 0 3 3 6 6 9 9 9 10 11 

Beispiel*: f[4,9]=btKnapsack(4,9)=10 (d.h. o 4 und o 5 haben bei 

Restkapazität 9 noch Platz: Wert der Füllung = 10) 

*Anstelle der Java-üblichen Schreibweise f[4][9] wird im Foglenden f[4,9] verwendet. 

6 

12/47


� Beachte zentrale Anweisungen in btKnapsack(i,r): 

� ... else return max( btKnapsack(i+1,restkapazität), 

� 

Bsp.: 

btKnapsack(i+1,restkapazität–o.gewicht())+o.wert() ) ... 

0 1 2 3 4 5 6 7 8 9 10 

5 0 0 0 0 6 6 6 6 6 6 

4 0 0 0 0 6 6 6 6 6 10 10 

3 0 0 0 0 6 6 6 6 6 10 11 

2 0 0 3 3 6 6 9 9 9 10 11 

f[3,8] = max(f[4,8], f[4,2]+5) = max(6,0+5) = 6 

Idee für dynamische Programmierung verfeinert: 

1. Berechnung der Werte für i=n und alle Restkapazitäten von 0 bis c. 

2. Dann von i=n-1 bis 2 Berechnung der Feldeinträge für jeweils alle Kapazitäten 

unter Rückgriff auf die bereits berechneten Werte der Zeile i+1. 

3. Gesamtergebnis f[1,c] dann durch Einzelberechnung 

(f[1,10] = max(f[2,10], f[2,8]+6) = max(11,9+6) = 15). 

6 

13/47


Dynamische Programmierung in Java Pseudocode: 

public int dpKnapsack(int n, int c ) {// Aufruf: dpKnapsack(objekte.length,c) 

int[][] f = new int[2,n][0,c]; // Deklaration des Feldes (CAVE: Java-unüblich) 

// Initialisierung des Feldes für i = n 

for (int r = 0; r r ) f[n,r] = 0; 

else f[n,r] = objekte[n].wert(); 

// Berechnung des Feldes für i = n-1,...,2 

for (int i = n-1; i >=2; i = i-1) 

for (int r = 0; r r ) f[i,r] = f[i+1,r]; 

else f[i,r] = max( f[i+1,r], f[i+1, r- objekte[i].gewicht()] 

+objekte[i].wert() ); 

// Berechne f[1,c] (den maximal erreichbaren Wert) 

if ( objekte[1].gewicht() > c ) return f[2,c]; 

else return max( f[2,c], f[2, c-objekte[1].gewicht()] + objekte[1].wert() ); 

} 

14/47

Textsuche 

� Problem: Finden eines Wortes in einem (längeren) Text. 

� Konkret: 

� Gegeben: 

- Array a von Zeichen der Länge n 

(Bsp.: a="Eine Rose ist eine Rose ist eine Rose") 

- Array s von Zeichen der Länge m (i.d.R. m

Textsuche – Brute-Force-Lösung 

� Brute-Force-Lösung: 

� Suche ersten übereinstimmenden Buchstaben (Laufindex i). 

� Falls gefunden an Position i=j: vergleiche nachfolgende Buchstaben 

� Falls erfolgreich: Ende und Rückgabe von i 

� Falls nicht erfolgreich: erhöhe i um 1 und mache weiter mit Schritt 1 

Konkret (Java-Pseudocode): 

public int bruteForceSearch( char[] a, char[] s ) { 

int k; // Laufvariable 

for (int i = 0; i

Textsuche - Beispiel 

a 

s 

0 1 2 3 4 5 6 7 

8 9 10 11 12 13 14 15 ... 

E i n e R o s e i s t e i 

R o s e 

i=0 (k=0) R o s e 

i=1 (k=0) R o s e 

i=2..3 (k=0) ... 

i=4 (k=0) R o s e 

i=5 (k=0) R o s e 

i=5 (k=1) R o s e 

i=5 (k=2) R o s e 

s.length=4 // ...relevanter Teil: 

for (int i = 0; i

Textsuche – Laufzeit bei Brute-Force 

� Maßstab für Laufzeit: 

Anzahl Vergleiche 

� Worst-Case: 

� Auftreten Worst-Case: 

Wenn ab jeder Position in a die Zeichenkette s bis auf das letzte 

Zeichen auftritt. 

Beispiel: a="aaaaaaaaaaaaaaaaaab" s="aaab" 

=> (3) wird bei jedem Zeichen aus a betreten (d.h. n-m Mal) 

und vollständig (d.h. m Mal) durchlaufen 

� Anzahl Vergleiche: (n-m)*m 

� Laufzeit: O((n-m)*m) = O(nm) 

� Gewünscht: Verbesserung der Laufzeit insbesondere für große Muster 

bzw. für große s. 

(1) 

(2) 

(3) 

(4) 

// Relevanter Teil: 

... for (int i = 0; i

Textsuche – Verbesserung 

Verschieben des Suchmusters bei Misserfolg des Vergleichs nicht um 1 

sondern um Entfernung e 

Problem: e hängt vom Muster s ab 

Beispiel 1: 

a="123123x123" und s="123x" (alle Zeichen verschieden) 

=> Bei Misserfolg kann bis zur Stelle des Mismatch verschoben 

werden. 

Beispiel 2: 

a=„345345345x123" und s=„345345x" (Teilmuster wiederholt sich) 

=> bei Misserfolg im 7‘ten Vergleich (k=6) muss a mit s ab Position 

4 von s verglichen werden (i=3 und k=3). 

Ablauf: i=0 > Übereinstimmung 0.-5. Zeichen > Fehler bei 

k=6 > i=i+3 ... 

19/47

Algorithmus von Knuth-Morris-Pratt(1/5): 

� Idee: Für jedes Zeichen s[k] im Muster merken, um wie viele 

Positionen bei Misserfolg des Vergleiches a[i+k]==s[k] in a 

vorangeschritten werden kann. 

� Hilfsstruktur hierfür: int[] dis = new int[s.length] 

� Achtung: Index i wird mit k inkrementiert. Mittels dis[] wird k 

korrigiert! 

Beispiel: 

a 

0 1 2 3 4 5 6 7 

dis -1 0 0 0 1 1 

i=0..4, k=0..4 s A B C A A B 

i=4..5, k=1..2 

i=5..7, k=0..2 

8 9 10 11 12 13 14 

A B C A B A B A B C A A B A B 

A B C A A B 

Korrektur: k=1 

A B C A A B 



i=7..12, k=0..5 A B C A A B Rückgabe: i-k=7 

20/47

Algorithmus von Knuth-Morris-Pratt(2/5): 

� Problem: Bestimmen des Distanzfeldes dis. 

� Notwendig: Überprüfung des Musters auf sich wiederholende 

Teilmuster s[0]...s[j]. Findet sich eine Wiederholung des Umfanges j≥0 

links vom kritischen Vergleichsindex k, d.h. ist s[k-1-j] ...s[k-1] gleich 

s[0]...s[j], so kann der Vergleich s[0]...s[j] ausgelassen werden. D.h. k 

kann gleich j+1 gesetzt werden. 

Beispiel: 

a 

0 1 2 3 4 5 6 7 

i=0..4, k=0..4 s A B C A A B 

8 9 10 11 12 13 14 

A B C A B A B A B C A A B A B 

s[0]...s[0] ist gleich s[k-1-0]...s[k-1]=s[3] 

=> Verschieben auf k = j+1 = 0+1 = 1 

s A B C A A B 

k =1 ist zugleich der Index für 

den nächsten Vergleich! 

21/47

Algorithmus von Knuth-Morris-Pratt (3/5): 

� Lösungsidee zur Bestimmung des Distanzfeldes dis (grob): 

Eine Kopie des Musters wird am Muster selbst vorbei 

geschoben, wobei die überlappenden Zeichen verglichen 

werden. In dis werden die jeweils übereinstimmenden 

Zeichen gespeichert. 

Beispiel: 

s 

0 1 2 3 4 5 

A B C A A B 

dis[i] 

i=1 s A B C A A B 0 

i=2 s A B C A A B 0 

i=3 s 

A B C A A B 0 

i=4 s 

A B C A A B 1 

i=5 s 

A B C A A B 1 

dis[i]= "0 oder x+1, falls ∃x: 

s[i-1-x]...s[i-1]=s[0]...s[x]" 

Bei Ungleichheit nach rechts 

verschieben um ein Feld 

Verschieben stoppt bei 

Gleichheit! 

Bei erster Ungleichheit Verschieben 

wieder aufnehmen! 

22/47


Bestimmung des Distanzfeldes in Java Pseudocode: 

public int[] initDis(char[] s ) { 

int[] dis = new int[s.length]; // Deklaration des Feldes 

int i = 0, j = -1; // Deklaration/Initialisierung temporärer Laufvariablen 

dis[0] = -1; // Init. dis[0] 

// i „durchwandert“ das Muster von links (0) nach rechts bis s.length-2 

while (i < s.length-1) { 

// j „zählt“ die gleichen Anfangszeichen 

while (j >= 0 && s[i] != s[j]) j=dis[j]; // Schleifenrumpf nur bei s[i]≠s[j] relevant 

// hiernach ist s[i]=s[j]; 

//nur solange werden j und i inkrementiert u. dis[i] gesetzt 

i=i+1; j=j+1; 

dis[i] = j; 

} 

return dis; 

} 

23/47


Nun zur eigentlichen Suchfunktion in Java Pseudocode: 

public int kmpSearch(char[] a, char[] s ) { 

int[] dis = initDis(s); // Berechnung des Distanzfeldes 

int i = 0, j = 0; // Deklaration/Initialisierung temporärer Laufvariablen 

// i „durchwandert“ den Text von links (0) nach rechts bis a.length-1 

while (i < a.length) { 

// j „zählt“ die gleichen Anfangszeichen 

while (j >= 0 && s[j] != a[i]) j=dis[j]; // Schleifenrumpf nur bei a[i]≠s[j] relevant 

// hiernach ist a[i]=s[j]; nur solange werden j und i inkrementiert 

i=i+1; j=j+1; 

if (j==s.length) return i-s.length; 

} 

return -1; 

} 

24/47

Anmerkungen 

� Laufzeit von kmpSearch() : 

� Laufzeit initDis(): Maximal 2m Durchläufe => O(m) 

� Laufzeit kmpSearch(): O(m)+“Maximal 2n Durchläufe“ 

� O(n+m) 

� Vorteil von kmpSearch() entfaltet sich erst bei sich 

wiederholenden Textmustern im Suchstring. 

� Weiterer Vorteil: In der zu durchsuchenden Zeichenkette 

muss nie zurückgegangen werden (gut bei externen 

Speichermedien). 

� Was hat all dies mit dynamischer Programmierung zu tun: 

das hier eingesetzte Prinzip der Vorberechnung ist eine 

Spezialisierung der dynamischen Programmierung. 

� „Variante“ von kmpSearch(): Boyer-Moore 

25/47

Inhalt 




26/47

Verteilte Berechnungen 

� Analogon Hausbau: 

� Schritte: 

� Baugrube ausheben 

� Bodenplatte gießen 

� Mauern & Dach decken 

� Fenster einbauen 

� Türen einbauen 

� Tapezieren 

� ... 

� Abhängigkeiten sind 

einzuhalten! 

=> Paralleles Arbeiten 

erfordert Koordination 

Prinzipiell durch 

eine Person möglich 

=> Dauert 

(sehr) lange 

Besser: 

Teamwork 

=> Schnell, da 

parallel gearbeitet 

werden kann 

27/47

Parallelisierung/Sequenzialiserung 

� Lässt sich ein Problem in unabhängige Teilprobleme 

zerlegen, so bietet sich zwecks Steigerung der Effizienz die 

unabhängige Berechnung der Teilprobleme durch 

getrennte Prozessoren an (Parallelisierung): 

Nach Bearbeitung der Teilprobleme: Zusammenführen 

der Ergebnisse (Sequenzialisierung). 

... 

28/47

Prozesse 

� Zentraler Begriff: der Prozess (=Vorgang einer 

algorithmisch arbeitenden Informationsbearbeitung) 

� Konzept: Pro Zeiteinheit wird auf jedem Prozessor genau 

ein Prozess ausgeführt. 

� Prozesse haben Lebenszyklus (vereinfacht): 

� sie werden gestartet und laufen ab, 

� sie werden blockiert und warten (z.B. auf Eingabe), 

� sie werden wiederbelebt und laufen ab und 

� sie werden beendet und bleiben terminiert. 

� Ein Prozess kann sog. Kind-Prozesse anstoßen. 

Notwendig: Kommunikation von Prozessen 

(über Status des (Kind-)Prozesses, bzgl. Daten (z.B. 

Rechenergebnisse) etc.) 

suspend 

initiated 

running 

waiting 

start 

terminated 

29/47 

resume 

kill

Realisierung 

� Varianten (grob): 

� Mehrere Prozessoren befinden sich auf einer Platine 

(Mehrprozessorsystem) 

� In einem Netzwerk von Rechnern steht pro Rechner 

ein Prozessor zur Verfügung (Cluster) 

Kombinationen sind möglich! 

Prinzip: Ein Prozess gibt lediglich an, ob und welche 

Kind-Prozesse erzeugt und gestartet werden 

sollen. Die Verteilung und Durchführungskontrolle 

(inkl. Nachrichtenvermittlung) übernimmt das 

(Netzwerk-) Betriebssystem (abgek. BS). 

Multiprocessingsysteme ermöglichen virtuelle 

Parallelität auf nur einem Prozessor: Hier verteilt 

das BS Rechenzeit(scheiben) auf Prozesse. 

Windows 2000 

UNIX ... 

30/47

Modellierung verteilter Berechnung (1/3) 

� Petri-Netze (C.A. Petri 1962) dienen der Modellierung 

sogenannter nebenläufiger und nichtdeterministischer Abläufe. 

� Grundelemente dieser gerichteten Graphen: 

1. Transitionen: stellen elementaren Arbeitsschritt dar 

2. Stellen: Zwischenlager für "Datenobjekte„ 

zerlegen 

3. Marken: Datenobjekt/Kontrollfluss 

Teilproblem 1 

Bedingung: Nur zwischen Stellen und Transitionen (und umgekehrt) 

bestehen Verbindungen. 

Idee: Transitionen verarbeiten die Marken der Stellen ihres 

Vorbereichs und geben die Resultate an Stellen im Nachbereich ab 

Unsortierte Liste 

Sortieren 

t→t+1 

Sortierte Liste 

Unsortierte Liste 

Sortieren 

Sortierte Liste 

31/47

Modellierung verteilter Berechnung (2/3) 

� Petri-Netze formal (Definition): 

� Ein Petrinetz ist ein 4-Tupel (S,T,F,M) mit: 

� S≠∅ (Menge von Stellen) 

� T≠∅ ∧ S∩T=∅ (von S unterschiedliche Menge von Transitionen) 

� F⊆S×T ∪ T×S (Flussrelation zw. Stellen und Transitionen u.u.) 

� M: S→IN 0 (Startmarkierung der Stellen) 

� Weitere Definitionen: 

� •t = {s∈S|(s,t) ∈F} für t∈T 

(Vorbereich einer Transition) 

Beispiel: 

� t• = {s∈S|(t,s) ∈F} für t∈T 

(Nachbereich einer Transition) •t1={s1,s2} 

t1• ={s2,s3} 

s1 

s3 

s2 

t1 

32/47

Modellierung verteilter 

Berechnung (3/3) 

� Ausführbarkeit einer Transition t: Gilt für eine Markierung 

M': S→IN 0, dass ∀s ∈ •t : M'(s)≥1, so ist t ausführbar. 

� Semantik: Folge von Markierungen > Schaltregel 

� Schaltregel: Eine Markierung M': S→IN 0 kann aus einer Markierung M 

wie folgt hervorgehen: 

Beispiel: 

•t1={s1,s2} 

t1• ={s2,s3} 

M(s1)=3, M(s2)=1, 

M(s3)=1 

(=> t1 ausführbar) 

M'(s)= 

s1 

s3 

s2 

t1 

M(s)+1 falls t ausführbar, s∈t• aber s∉•t 

M(s)-1 falls t ausführbar, s∈•t aber s∉t• 

M(s) sonst 

M»M' 

s1 

s3 

s2 

t1 

M'(s1)=2, 

M'(s2)=1, 

M'(s3)=2 

33/47

Petri-Netze – Grundlegende Strukturen (1/2) 

• Sequentieller Ablauf Transition 1 Transition 2 

• Parallelisierung 

• Synchronisation 

(Sequenzialisierung) 

Transition 1 

Transition 1 

Transition 2 

Transition 2 

Transition 3 

Transition 3 

34/47

Petri-Netze – Grundlegende Strukturen (2/2) 

• Alternative 

Achtung ! 

Transition 1 

Markenfluß ist nicht deterministisch! 

• Schleife 

Transition 2 

Transition 3 

Transition 3 

Transition 1 Transition 2 

35/47

Beispiel: Hausbau 2 

Baugrube ausheben 

Grube 

ausgehoben 

Bau genehmigt 

Fundament giessen 

Keller mauern 

Bodenplatte giessen 

Fundament gegossen 

Türen sind 

einzubauen 

Türen 

eingebaut 

Mauern möglich 

Türen einbauen 

Mauern & Dach decken 

Haus fertig 

Fenster eingebaut 

Tapezieren 

Eigentlich Spezialfall von Petri-Netz: Bedingungs-/Ereignisnetz (> Kontrollfluss) 

Fenster 

sind 

einzubauen 

36/47 

Fenster einbauen

Weitere Aspekte 

� Erweiterungen von Petri-Netzen: 

� Stellen erhalten Kapazität (maximale Markenanzahl) 

� Beziehungen erhalten Gewicht (wird bei der Berechnung der 

Folgemarkierung anstelle "1" verwendet) 

� Marken werden gefärbt 

� u.s.w. (> Theoretische Informatik) 

� Petri-Netze (oder verwandte Beschreibugen) werden 

häufig für Prozessmodellierung eingesetzt; oft auch nur zur 

Veranschaulichung. 

� Potentielle Probleme nebenläufiger Prozesse: 

Deadlocks/Livelocks 

� Wichtiges Hilfsmittel für Koordination von Prozessen: 

Semaphoren (Dijkstra) > Regelung des Zugriffs auf 

gemeinsame Ressource 

37/47

Inhalt 




38/47

Zufallsgesteuerte Algorithmen 

� Grundprinzip 

� Grundmuster 

� Monte Carlo Algorithmen 

� Las Vegas Algorithmen 

� Allgemeiner Las Vegas Algorithmus 

� Macao Algorithmus 

39/47

Grundprinzip 

� Idee: Verwendung zufällig gewählter Daten, um die 

Laufzeit eines Algorithmus zu senken. 

� Einige Aufgaben sind heute überhaupt nur 

auf diese Weise effizient zu lösen. 

� Beispiel: Primzahleigenschaft großer Zahlen 

� Zentrale Eigenschaft zufallsgesteuerter Algorithmen: sie 

sind nicht deterministisch. 

� Zentrales Werkzeug zufallsgesteuerter Algorithmen: 

� Zufallszahlengeneratoren 

� Beispiel (Java): public static double random() der Klasse Math 

realisiert eine im Intervall [0,1[ gleichverteilte Zufallsvariable 

� S.a. Klasse Random 

40/47

Grundmuster für den Entwurf 

� Auswahl: aus einer Menge deterministischer Algorithmen 

zur Lösung eines Teilproblems wird zufällig einer 

ausgewählt 

� Stichprobe: aus einer zufällig gewählten Stichprobe von 

Daten wird auf Eigenschaft aller Daten geschlossen 

� Zeuge (Betrifft Ja/Nein-Entscheidungen): Auf hinreichend 

viele Daten (die Zeugen) angewendet bestätigen 

deterministische Alg. ein Ereignis mit Wahrscheinlichkeit 

p>0,5 (>Monte Carlo) 

� Umordnung: Eingabemenge wird zufällig umgeordnet 

(>etwaige für Laufzeit negative Trends zerstören) 

41/47

Monte Carlo Algorithmen 

� Prinzip: Monte Carlo Algorithmen (MCA) liefern nur mit einer 

Wahrscheinlichkeit p Bei Entscheidungsproblemen: p≠0,5 

� Grundmuster: 

� Ein MCA y:=mc(x) liefert ein korrektes Ergebnis nur mit 

Wahrscheinlichkeit p

MCA: Beispiel 

� Berechnung der Zahl π. 

� Formel für Kreisfläche: A= πr² 

� Betrachte Einheitskreis im 1. Quadranten 

Seien x und y Zufallszahlen aus [0,1[. 

⇒ p:=P( (x, y)∈A' )=A'/1= π/4 

1 

A' 

⇒A'= πr²/4= π/4 

Fläche Quadrat=1 

Wird dieses Experiment n Mal wiederholt und "landen" c Punkte (x,y) 

in A', so gilt π(n)=4c/n 

Beispiel: In einem Zufallsexperiment mit 10000 gleichverteilten 

Punkten (x,y) ∈ [0,1[×[0,1[ erfüllen 7874 Punkte die Bedingung x²+y² π(10000)=4*7874/10000=3.1496 (für den Fehler gilt: εMC-Integration) 

1 

43/47

Las Vegas Algorithmen 

� Prinzip: Im Ggs. zu MCA liefert ein Las Vegas Algorithmus (LVA) immer das 

richtige Ergebnis, wenn er terminiert. 

� Unterscheidung: 

� Er terminiert mit Wahrscheinlichkeit presult) und dabei Zufallszahlen verwendet. Sie testet zudem, 

// ob das Ergebnis richtig ist und gibt das Resultat zurück (>erfolg) 

return result; 

} 

44/47

Allg. LVA: Eigenschaften/Beispiel 

� Es gibt keine obere Schranke für die Laufzeit des allgemeinen LVA. 

� Grund: Im Extremfall werden unendlich viele schlechte Ergebnisse 

geraten und immer wieder verworfen. 

� Daher Forderung: der ungünstigste erwartete Fall ist immer endlich. 

� Beispiel: Zufälliges Färben von Elementen 

� Gegeben: Menge S mit n Elementen, paarweise verschiedene 

Untermengen S0,...,Sk-1⊆S mit |Si| = r > 0. Es gelte k≤2r-2. 

� Gesucht: Färbung der Elemente von S derart, dass jedes Si wenigstens ein 

rotes und ein schwarzes Element enthält. 

� Algorithmus: suggestResultSimple() ordnet jedem Element zufällig 

irgendeine Farbe zu und gibt zurück, ob erfolgreich. 

� Offensichtlich: Nicht immer korrekte Lösung. 

� Frage: Wahrscheinlichkeit für falsche Lösung? 

45/47

Allg. LVA: Beispiel Fortsetzung 

Frage: Wahrscheinlichkeit für falsche Lösung? 

P(ein Element wird rot gefärbt) 

= P(ein Element wird schwarz gefärbt) = 1/2 

P(alle Elemente von Si sind rot) = 1/ 2r = 2-r 

P(irgend ein Si ist vollständig rot gefärbt) ≤ k*2-r 

Voraussetzung: k≤2r-2 

Damit: P(irgend ein Si ist vollständig rot gefärbt) ≤ k*2-r ≤ 2r-2*2-r = 1/4 

=> P(irgend ein Si ist einheitlich (rot oder schwarz) gefärbt) ≤ 1/2 

=> suggestResultSimple() liefert 

mit einer Wahrscheinlichkeit ≤ 1/2 eine falsche Lösung und 

mit einer Wahrscheinlichkeit ≥ 1-1/2=1/2 eine korrekte Lösung 

(Voraussetzung für allg. LVA erfüllt) 

46/47

Macao Algorithmen 

� Macao Algorithmen entstehen meist aus gewöhnlichen 

deterministischen Algorithmen, indem 

� die Elemente der Eingabemenge in zufälliger Folge bearbeitet 

werden, oder 

� ein Zufallsgenerator genutzt wird, um ein Element zufällig zu 

wählen. 

� Beispiel für 1.: randomizedInputArrayQuickSort() 

� Beispiel für 2.: quickSort() mit determinePivotElement()- 

Dienst, der auf zufälliger Auswahl des Pivot-Elements 

beruht 

47/47

Algorithmen und Datenstrukturen

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?