2. Übung -- Algorithmen II - Johannes Singler - am Institut für ...

2. Übung – Algorithmen II 

Johannes Singler 

Institut für Theoretische Informatik, Prof. Sanders 

1 Johannes Singler: 


Fakultät für Informatik 

Institut für Theoretische Informatik 

KIT – Universität des Landes Baden-Württemberg und 

nationales Forschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu

Organisatorisches 

Musterlösung des ersten Übungsblatts steht seit heute online. 

Das zweite Übungsblatt erscheint am Dienstag, 9.11. 




Institut für Theoretische Informatik

Inhalt heute 

1 Wiederholung zum 

Beweis durchschnittliche Anzahl decreaseKeys 

2 Radix Heaps konzeptuell 

3 Anwendung Kürzeste Wege: Mitfahrgelegenheiten 





Durchschnittliche Anzahl decreaseKeys 

für Jarník-Prim 

Motivation 

Algorithmus zur Berechnung minimaler Spannbäume 

(siehe Algorithmen I) 

Beweis analog zum Algorithmus von Dijkstra 

Wie viele decreaseKeys im Durchschnitt? 

beliebiger Graph G 

beliebiger Startknoten s 

Menge {1, . . . , m} von Kantengewichten 

eigentlich ausreichend: verschieden 

Gemittelt wird über alle Zuteilungen von Kantengewichten 







zu beweisen: E[#decreaseKey-Operationen] = O � n log m � 

n 

d[v] ist Abstand zum vorläufigen Spannbaum S, 

zu Beginn ∞ 

decreaseKey wird aufgerufen, 

wenn neuer Knoten u zu S hinzugenommen wird 

mit c((u, v)) < d[v] (und v /∈ S, ignorieren wir) 

für einen Knoten v: 

decreaseKey bei Bearbeitung von Kante 

e i = (u i, v) nur wenn 



c(e i) < min 

j



zu beweisen: E[#decreaseKey-Operationen] = O � n log m � 

n 

Reihenfolge der Kanten unabhängig vom 

Gewicht ⇒ zufällig 

Wie oft findet man ein neues Minimum? 



S 

u 1 

u 

i 

e i 

e 1 


Institut für Theoretische Informatik 

v

Präfixminima einer Zufallsfolge 

Definiere Zufallsvariable Mn als Anzahl Präfixminima einer Folge von n 

verschiedenen Zahlen (in Abhängigkeit von einer Zufallspermutation). 

Definiere Indikatorzufallsvariable Ii = 1 gdw. die i-te Zahl ein 

Präfixminimum ist. 



E(Mn) = E( 

= 

n 

∑ 

i=1 

I i) Lin.E(·) 

= 

n 

∑ E(Ii) i=1 

n 

1 

∑ i 

i=1 

= Hn wegen P [Ii = 1] = 1 

i 

x1, . . . , xi−1, xi, xi+1, . . . , xn 

� �� 



erstes Minimum führt zu insert(v) 

also für Knoten v: 

≤ Hk − 1 ≤ ln k erwartete decreaseKeys mit k = indegree(v) 

insgesamt 

∑ ln indegree(v) ≤ n ln 

v∈V 

m 

n 

wegen Jensens Ungleichung 



n 

∑ f (xi) ≤ n · f 

i=1 

� n � 

∑i=1 xi n 

mit f = ln und x i = indegree(v) und ln konkav 



Jensens Ungleichung 

für konvexe Funktionen: 

jede Verbindungsgerade 

zwischen zwei Funktionspunkten 

liegt überhalb der Funktion 



n 

∑ f (xi) ≥ n · f 

i=1 

f(y) 

t f(x) + (1-t) f(y) 

f(xt + y(1-t)) 

f(x) 

� ∑ n i=1 x i 

n 

x xt + y(1-t) y 

analog für konkave Funktionen: 

jede Verbindungsgerade zwischen zwei Funktionspunkten 

liegt unterhalb der Funktion 

n 

∑ f (xi) ≤ n · f 

i=1 

� 

� n � 

∑i=1 xi n 



Radix-Heaps konzeptuell 

konzeptuell: Radix Heap fasst eine Ebene eines Binären Heaps in 

einem Bucket zusammen. 



2 

10 8 

Binary Heap 

0 

4 

13 5 

Radix Heap 

0 

2, 4 

10, 8, 13, 5 

(Heap-)Baum entartet zu einer Liste (Unärbaum), dafür mit vielen 

Elementen pro Knoten 

⇒ Buckets werden nach unten exponentiell größer 

Tiefe analog 






2 

10 8 

Binary Heap 

0 

4 

13 5 

Radix Heap 

0 

2, 4 

10, 8, 13, 5 

Was ist die Abstraktion? (Was stimmt nicht wirklich?) 

Füllgrad der Buckets ist variabel 

bei Sprüngen in der Schlüsselwerten sind viele obere Buckets leer 

Schlüssel einer Ebene im Binären Heap nicht unbedingt 

konsistent in Buckets packbar 

Einteilung hängt von konkretem Wert ab, 

nicht nur von (vergleichendem) Rang 




Vorteile 

keine iteratives siftUp/siftDown über volle Höhe mehr nötig 

zur Aktualisierung von min, 

Ziel-Bucket kann in konstanter Zeit gefunden werden 

vgl. Bucketsort: wahlfreier Zugriff statt (mehrere) Vergleiche 

Bedingungen 

Schlüssel sind Ganzzahlen 

um Bucket direkt ausrechnen zu können 

Wertebereich ist beschränkt 

um Anzahl Buckets beschränken zu können 

deleteMin muss ggf. jedes Mal alle Buckets überprüfen, 

bis es den ersten nicht-leeren gefunden hat. 

nur effizient wenn beschränkt 






Warum die ganze Bit-Fummelei? 

Könnte man nicht viel anschaulicher 

nehmen? 



i := ⌈log 2 (d[v] − min)⌉ 

erstmal okay: Anzahl Verschiebungen würde sich nicht erhöhen 

Jedes Element durchwandert jeden Bucket höchstens einmal. 




Warum die ganze Bit-Fummelei? 

Könnte man nicht viel anschaulicher 

nehmen? 



i := ⌈log 2 (d[v] − min)⌉ 

erstmal okay: Anzahl Verschiebungen würde sich nicht erhöhen 

Jedes Element durchwandert jeden Bucket höchstens einmal. 

Problem: 

Änderung von min ändert alle d[v] − min und damit potentiell alle i. 

Das müsste bei zu vielen Elementen überprüft werden. 

⇒ schlechtere Laufzeit 



Anwendung von schneller 

Kürzeste-Wege-Berechnung 

aus der aktuellen Forschung 

nicht prüfungsrelevant 

Mitfahrgelegenheiten 

das Wort hat Robert Geisberger 





Umfrage nach gewünschten Inhalten 

in der Übung 

Was hätten Sie am liebsten in der Übung? 

Wiederholung mittels ähnlichem Stoff, konzeptuell/Vergleiche 

(wie heute)? 

Blick über den Tellerrand (nicht prüfungsrelevant, auch wie heute)? 

(Weitere) Beispiele? 

Applets mit Algorithmen-Demos (wie letztes Mal)? 

Vorrechnen des Übungsblatts? 

Was wäre Ihnen heute am liebsten gewesen 

(Meinungen ins Diskussionsforum, bitte!)? 

Elektronische Umfrage im ILIAS-System (Link auf Homepage) 

Mehrfachnennung möglich

2. Übung -- Algorithmen II - Johannes Singler - am Institut für ...

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?