Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

10.11.2013Kapitel 21 Methoden des Algorithmenentwurfs Kapitel 2.1: Deterministische Online Algorithmen Christian Scheideler SS 2009.

Ähnliche Präsentationen


Präsentation zum Thema: "10.11.2013Kapitel 21 Methoden des Algorithmenentwurfs Kapitel 2.1: Deterministische Online Algorithmen Christian Scheideler SS 2009."—  Präsentation transkript:

1 Kapitel 21 Methoden des Algorithmenentwurfs Kapitel 2.1: Deterministische Online Algorithmen Christian Scheideler SS 2009

2 Übersicht Beispiele Notation Paging Scheduling Selbstorganisierende Suchstrukturen Kapitel 22

3 Beipiele Ski-Problem: Ein Paar Ski kann für 500 gekauft oder für 50 geliehen werden. Wie lange soll geliehen werden, bevor man sich für den Kauf entscheidet, wenn nicht bekannt ist, wie lange man noch Ski fährt? Optimale Strategie (falls Zukunft nicht bekannt): So lange Ski leihen, bis die Leihkosten gleich den Kaufkosten sind Kapitel 23

4 Beispiele Geldwechselproblem: Ein Geldbetrag (z.B ) soll in eine andere Währung (z.B. $) gewechselt werden. Zu welchem Zeitpunkt soll getauscht werden, wenn nicht bekannt ist, wie sich der Wechselkurs entwickelt? Kapitel 24

5 Beispiele Paging/Caching: Es soll ein zweistufiges Speichersystem verwaltet werden, das aus einem schnellen Speicher mit kleiner Kapazität und einem langsamen Speicher mit großer Kapazität besteht. Dabei müssen Anfragen auf Speicherseiten bedient werden. Welche Seiten hält man im Cache, um die Anzahl der Cache-Misses zu minimieren? Kapitel 25 Hauptspeicher Cache

6 Beispiele Verteilte Systeme: Daten sollen in einem Netzwerk dynamisch so platziert werden, dass möglichst wenige Daten übertragen werden müssen, um die Anfragen zu bedienen Kapitel 26

7 Beispiele Scheduling: Jobs mit im Voraus bekannter Bearbeitungsdauer treffen hintereinander ein und sollen von m Maschinen bearbeitet werden. Die Jobs müssen dabei unmittelbar einer bestimmten Maschine zugeordnet werden. Hier gibt es verschiedene Optimierungsziele, z.B. die Minimierung der Gesamtbearbeitungszeit Kapitel 27

8 Notation Online Problem: Statt einer vollständig gegebenen Eingabe I haben wir jetzt eine Eingabesequenz =( (1), (2),…, (t)), in der die Eingabeteile (i) erst nach und nach an den Online Algorithmus übergeben werden. Nach jedem (i) muss der Online Algorithmus eine Entscheidung treffen, bevor er (i+1)… (t) gesehen hat. Diese Entscheidung kann (im Standard-Online-Modell) nicht wieder zurück- genommen werden (wie beim Schach) Kapitel 28

9 Notation 1.1 Definition: Sei ein Optimierungs- problem und A ein Online Algorithmus für. Für eine beliebige Eingabesequenz =( (1), (2),…, (t)) seien A( ) die Kosten von A für. A heißt c-kompetitiv, wenn es einen von t unabhängigen Parameter a gibt, so dass für alle Eingabesequenzen gilt: A( ) c OPT( ) + a Kapitel 29

10 Übersicht Beispiele Notation Paging Scheduling Selbstorganisierende Suchstrukturen Kapitel 210

11 Paging Problem: Eine online eintreffende Folge von Seitenanfragen =(x 1,…,x n ) muss durch ein zweistufiges Speichersystem (Cache und Hauptspeicher) bearbeitet werden. Ist eine Seite nicht im Cache vorhanden (Cache-Miss), muss sie vom Hauptspeicher dorthin geladen werden (und verdrängt bei vollem Cache eine dort vorhandene Seite). Ziel: minimiere die Anzahl der Cache-Misses Offline Fall: alle Seitenanfragen im vornherein gegeben. Offline-Algorithmus: MIN Entferne stets diejenige Seite aus dem Cache, deren nächste Anfrage am weitesten in der Zukunft liegt Kapitel 211

12 Paging 1.2 Satz: MIN ist ein optimaler Offline-Algorith- mus, d.h. er erzeugt für jede Anfragesequenz die minimale Anzahl an Seitenfehlern. Beweis: : beliebige Anfragefolge A: optimaler Algorithmus auf Wir bauen A so um, dass er wie MIN arbeitet. Die Anzahl der Seitenersetzungen wird dabei nicht erhöht Kapitel 212

13 Paging Beweis (Fortsetzung): Behauptung: angenommen, A und MIN arbeiten auf den ersten i-1 Anfragen identisch, aber auf der i-ten Anfrage verschieden. Dann kann A in Algorithmus A´ transformiert werden, so dass gilt: –A´ und MIN arbeiten auf der ersten i Anfragen identisch –A´( ) A( ) Ist diese Behauptung gezeigt, dann können wir A schrittweise in MIN umformen, ohne die Kosten zu erhöhen Kapitel 213

14 Paging Beweis (Fortsetzung): Wir beweisen nun die Behauptung Die i-te Anfrage referenziere Seite x. A entferne dafür die Seite u aus dem Cache und MIN die Seite v. Algorithmus A´: arbeitet auf den ersten i-1 Anfragen wie A und entfernt bei Anfrage i die Seite v. A´simuliert dann A, bis eines der folgenden Ereignisse eintrifft: –a) Ersetzt A die Seite v, dann ersetzt A´ zum gleichen Zeitpunkt die Seite u. –b) u wird angefragt und A ersetzt z. In diesem Fall ersetzt A´ die Seite z durch v. v kann nicht vor u angefragt werden, da sonst die MIN-Regel verletzt wird. In beiden Fällen sind A und A´ dann wieder in identischen Konfigurationen und A´ arbeitet wie A weiter. Die Anzahl der Seitenersetzungen hat sich dabei nicht erhöht Kapitel 214

15 Paging Leider ist MIN ein offline Algorithmus (d.h. er muss die gesamte Anfragefolge im vornherein kennen). Ein oft verwendeter Online Algorithmus ist der folgende: Algorithmus LRU (Least-Recently-Used): Entferne stets die Seite, die am längsten nicht mehr benutzt wurde. Im worst case ist LRU allerdings recht schlecht, wie die folgenden beiden Resultate zeigen Kapitel 215

16 Paging 1.3 Satz: Für einen Cache der Größe k ist LRU k- kompetitiv. Beweis: Wir betrachten eine beliebige Anfragefolge. LRU und OPT starten mit denselben Seiten im Cache. Wir zerlegen in Phasen P(1), P(2),…, so dass LRU in jedem P(i) mit i 2 jeweils exakt k Seitenfehler hat und in der Phase P(1) höchstens einen Seitenfehler. Können wir zeigen, dass OPT in jeder dieser Phasen mindestens einen Seitenfehler hat, so folgt der Satz. Für Phase P(1) ist das sicherlich wahr, da LRU und OPT anfangs dieselben Seiten haben Kapitel 216

17 Paging Beweis (Fortsetzung): Seien p 1,…,p k die Fehlerstellen von LRU in Phase P(i) mit i 2 und q die letzte vorangegangene Anfrage. Wir unterscheiden die folgenden Fälle: 1. i j p i p j und i p i q: Beim Phasenwechsel hat OPT q im Cache und kann höchstens k-1 der Seiten p 1,…,p k im Cache haben. Also tritt bei OPT mindestens ein Seitenfehler auf. 2. i j p i =p j : Zwischen den Anfragen p i und p j müssen mindestens k andere verschiedene Seiten angefragt worden sein, sonst hätte LRU diese Seite ja nicht aus dem Cache entfernt. Also gibt es k+1 verschiedene Seiten in dieser Phase und OPT muss mindestens einen Seitenfehler haben. 3. i j p i p j, aber i p i =q: Analog zur Argumentation bei Punkt 2 müssten zwischen q und p i mindestens k andere verschiedene Seiten angefragt worden sein Kapitel 217

18 Paging 1.4 Satz: Sei A ein deterministischer online Paging-Algorithmus. Ist A c-kompetitiv, dann ist c k. Beweis: Wir geben eine Folge an, die k+1 verschiedene Seiten p 1,…,p k+1 verwendet. Anfangs seien die Seiten p 1,…,p k im Cache. Der Gegner fragt nun stets diejenige Seite an, die bei A nicht im Cache vorhanden ist. Bei A tritt also bei jeder Anfrage ein Seitenfehler auf, d.h. A( )=| |. OPT muss höchstens alle k Anfragen eine Seite ersetzen, da nur k+1 Seiten vorhanden sind, und also nach einem Seitenfehler auf jeden Fall die nächsten k Seiten im Speicher sind. Damit ist c=A( )/OPT( ) | |/(| |/k) = k Kapitel 218

19 Paging Bemerkung: Auch wenn LRU im worst case eine schlechte Kompetitivität hat, so gibt es dennoch keinen besseren deterministischen Algorithmus. In der Tat gibt es sogar deterministische Algorithmen mit unbeschränkter Kompetitivität: Algorithmus MRU (Most-Recently-Used): Entferne diejenige Seite, die zuletzt gefragt wurde Betrachte die Sequenz =p 1,…, p k, p k+1, p k, p k+1,… Bei MRU sind die Seitenfehler unbeschränkt während OPT nur einen Seitenfehler hat Kapitel 219

20 Übersicht Beispiele Notation Paging Scheduling Selbstorganisierende Suchstrukturen Kapitel 220

21 Scheduling Problem: Eine online eintreffende Folge von Jobs =(J 1,…,J n ) soll auf m identischen Maschinen verteilt werden. Jeder Job J i sei spezifiziert durch eine Ausgabezeit t i IN und Bearbeitungszeit p i IN, wobei t i

22 Scheduling 1.5 Satz: Greedy ist 3-kompetitiv. Beweis: Sei t der letzte Zeitpunkt, zu dem eine Maschine unbeschäftigt ist, bevor sie bis zum Ende beschäftigt ist, und sei M diese Maschine. Für alle Jobs, die vor dem Zeitpunkt t generiert wurden, gilt, dass diese vor t mit der Bearbeitung begonnen haben, denn ansonsten hätte Greedy diese M zugewiesen Kapitel 222 t M

23 Scheduling Beweis (Fortsetzung): Sei J die Menge der Jobs, die nach t generiert werden. Ergänzen wir J um die nach t noch abzuarbei- tenden Reste der Jobs, die vor t generiert worden sind, auf J´, so ergibt sich für diese Jobmenge ein Greedy Schedule wie für den Greedy Approximationsalgorithmus Kapitel 223 t M J´

24 Kapitel 224 Scheduling Beweis (Fortsetzung): J bestehe aus n Jobs mit Aufwand p 1,…, p n Betrache Maschine i mit höchster Last L i. Sei j der letzte Job in Maschine i. Da Job j Maschine i zugeordnet wurde, hatte i vorher die kleinste Last. Es gilt also L i – p j L k für alle k. vor j j nach j L i - t j LiLi t

25 Kapitel 225 Scheduling Beweis (Forsetzung): Es gilt: L i -p j L k für alle k {1,…,m} und damit L k L i – p max. Wir wissen: j=1 m L j j=1 n p j +(m-1) p max Also ist L i +(m-1)(L i – 2p max ) j=1 n p j Daraus folgt: m L i j=1 n p j +(m-1) 2p max L i (1/m) j=1 n p j +2((m-1)/m) p max OPT( ) + 2(1-1/m) OPT( ) 3 OPT( ) Alte Jobs vor t

26 Kapitel 226 Scheduling Genauere Analyse: Greedy ist 2-1/m-kompetitiv. Ist das scharf? Ja! Beispiel: m Maschinen, m(m-1) Jobs der Länge L>>m(m-1), (so dass Zeit für Genierung der Jobs vernachlässigbar) ein Job der Länge m L m=10 Makespan ~ 19L

27 Kapitel 227 Scheduling Genauere Analyse: Greedy ist 2-1/m-kompetitiv. Ist das scharf? Ja! Beispiel: m Maschinen, m(m-1) Jobs der Länge L>>m(m-1), (so dass Zeit für Genierung der Jobs vernachlässigbar) ein Job der Länge m L m=10 Optimaler Makespan ~ 10L

28 Übersicht Beispiele Notation Paging Scheduling Selbstorganisierende Suchstrukturen Kapitel 228

29 Kapitel 429 Wörterbuch

30 Kapitel 430 Wörterbuch insert(15) 15

31 Kapitel 431 Wörterbuch delete(20) 15

32 Kapitel 432 Wörterbuch lookup(8) ergibt 8 15

33 Kapitel 233 Suchstruktur S: Menge von Elementen Jedes Element e identifiziert über key(e). Operationen: S.insert(e: Element): S:=S {e} S.delete(k: Key): S:=S\{e}, wobei e das Element ist mit key(e)=k S.lookup(k: Key): gibt e S aus mit key(e)=k, falls es ein solches e gibt, und sonst

34 Kapitel 234 Statische Suchstruktur 1. Speichere Elemente in sortiertem Feld. lookup: über binäre Suche ( O(log n) Zeit ) lookup(14)

35 Kapitel 235 Binäre Suche Eingabe: Zahl x und ein sortiertes Feld A[1],…,A[n] Binäre Suche Algorithmus: l:=1; r:=n while l < r do m:=(r+l) div 2 if A[m] = x then return m if A[m] < x then l:=m+1 else r:=m return l

36 Kapitel 236 Dynamische Suchstruktur insert und delete Operationen: Sortiertes Feld schwierig zu aktualisieren! Worst case: (n) Zeit

37 Kapitel 237 Suchstruktur 2. Sortierte Liste (mit -Element) Problem: insert, delete und lookup kosten im worst case (n) Zeit (z.B. ständig wird 19 angefragt) Besser: sortiere Elemente nach Zugriffshäufigkeit, aber Zugriffshäufigkeit nicht von vornherein bekannt. Was ist online möglich? 3 1 … 19

38 Kapitel 238 Suchstruktur 2. Sortierte Liste (mit -Element) Zentrale Frage: für welche insert, delete und lookup Operationen weichen wir für jede gegebene Operationsfolge so wenig wie möglich ab von der Laufzeit eines optimalen Offline Algorithmus, der alle Anfragen zu Beginn an kennt und damit eine optimale Strategie für die Anordnung und Umordnung der Elemente in der Liste berechnen kann? 3 1 … 19

39 Selbstorganisierende Liste Sei eine beliebige lookup-Anfragefolge gegeben. Bei einem Zugriff auf ein Listenelement entstehen Kosten, die von der Position des Elements abhängen. Das angefragte Element kann nach seiner Anfrage an eine beliebige Position weiter vorne in der Liste bewegt werden (mit keinen Zusatzkosten). Außerdem ist es möglich, zwei benachbarte Elemente mit Kosten 1 zu vertauschen Kapitel 239 k Kosten 7 kk lookup(k)

40 Selbstorganisierende Liste Die folgenden Online Strategien bieten sich an: Move-to-Front (MTF): Das angefragte Element wird an den Kopf der Liste bewegt. Transpose: Das angefragte Element wird mit dem Vorgänger in der Liste vertauscht. Frequency-Count (FC): Verwalte für jedes Element der Liste einen Zähler, der mit Null initiailisiert wird. Bei jeder Anfrage wird der Zähler um eins erhöht. Die Liste wird nach jeder Anfrage gemäß nicht steigenden Zählerständen sortiert. Interessanterweise ist MTF die beste Strategie Kapitel 240

41 Kapitel 241 Exkurs: Amortisierte Analyse S: Zustandsraum einer Datenstruktur : beliebige Folge von Operationen Op 1, Op 2, Op 3,…,Op n s 0 : Anfangszustand der Datenstruktur Zeitaufwand T( ) = i=1 n T Op i (s i-1 ) s0s0 Op 1 s1s1 Op 2 s2s2 Op 3 snsn Op n ….

42 Kapitel 242 Exkurs: Amortisierte Analyse Zeitaufwand T( ) = i=1 n T Op i (s i-1 ) Eine Familie von Funktionen A X (s), eine pro Operation X, heißt Familie amortisier- ter Zeitschranken falls für jede Sequenz von Operationen gilt T( ) A( ) := c + i=1 n A Op i (s i-1 ) für eine Konstante c unabhängig von

43 Kapitel 243 Exkurs: Amortisierte Analyse 1.6 Satz: Sei S der Zustandsraum einer Datenstruktur, sei s 0 der Anfangszustand und sei :S IR + eine nichtnegative Funktion. Für eine Operation X und einen Zustand s mit s s´ definiere A X (s) := (s´) - (s) + T X (s). Dann sind die Funktionen A X (s) eine Familie amortisierter Zeitschranken. X

44 Kapitel 244 Exkurs: Amortisierte Analyse Zu zeigen: T( ) c + i=1 n A Op i (s i-1 ) Beweis: i=1 n A Op i (s i-1 ) = i=1 n [ (s i ) - (s i-1 ) + T Op i (s i-1 )] = T( ) + i=1 n [ (s i ) - (s i-1 )] = T( ) + (s n ) - (s 0 ) T( ) = i=1 n A Op i (s i-1 ) + (s 0 ) - (s n ) i=1 n A Op i (s i-1 ) + (s 0 ) konstant

45 Selbstorganisierende Liste 1.7 Satz: MTF ist 2-kompetitiv. Beweis: Wir zeigen mit amortisierter Analyse, dass A(s) 2 OPT(s) ist. Wir verwenden die Potentialfunktion, die eine Konfiguration von A und OPT auf eine reelle Zahl abbildet, wobei für alle t (t) 0 und (0)=0 gilt. Wir wollen zeigen, dass für alle Zeitpunkte t gilt: A( (t))+ (t)- (t-1) c OPT( (t)) Damit ist A c-kompetitiv, denn durch das Summieren über alle t ergibt sich: t=1 m (A( (t))+ (t)- (t-1)) c t=1 m OPT( (t)) A( )+ (m)- (0) c OPT( ) A( ) c OPT( ) - (m) c OPT( ) Kapitel 245

46 Selbstorganisierende Liste Beweis (Fortsetzung): Wir wählen als Potentialfunktion die Anzahl der Inversionen in der Liste, wobei eine Inversion ein geordnetes Paar (x,y) von Listenelementen ist, so dass x vor y in OPT´s Liste ist und x hinter y in MTF´s Liste ist Kapitel MTF: OPT: Inversionen: (1,2), (2,3), (2,4), (2,5), (2,7), (2,8), (2,9), (3,4), (3,8), (3,9), (4,7), (5,8), (7,9)

47 Selbstorganisierende Liste Beweis (Fortsetzung): Sei (t)=x. x befinde sich direkt nach k in OPTs Liste und direkt nach l in MTFs Liste. Außerdem verschiebe OPT das Listenelement x nach vorne, so dass es direkt nach dem Listenelement i eingeführt wird Kapitel 247 ikx OPT: ilx MTF:

48 Selbstorganisierende Liste Durch OPTs Verschieben von x nach vorne können höchstens k-i neue Inversionen entstehen. Durch MTFs Verschieben von x werden anschließend l-i Inversionen aufgehoben und höchstens i neue Inversionen erzeugt. Also gilt: MTF( (t))+DF(t)) (l+1)+(k-i)+(i-(l-i)) = k+i+1 2k+1 < 2(k+1) = 2 OPT( (t)) Kapitel 248

49 Selbstorganisierende Liste Bemerkung: Satz 1.7 lässt sich für insert- und delete-Operationen erweitern, wenn diese wie folgt implementiert werden. Insert(e): Füge Element e vorne in die Liste ein. Delete(k): Lösche Element e mit key(e)=k aus der Liste raus Kapitel 249

50 Selbstorganisierende Liste 1.8 Satz: Sei A ein deterministischer online Algorithmus für selbstorganisierende Listen. Ist A c-kompetitiv, dann ist c 2. Beweis: Sei eine Liste mit n Elementen gegeben. Der Gegner erzeugt eine Anfragesequenz, in der stets das letzte Element in A´s Liste angefragt wird. Für | |=m ist A( )=m n Kapitel 250

51 Selbstorganisierende Liste Beweis (Fortsetzung): Wir betrachten die Offline-Strategie SL, die mit einer statischen Liste beantwortet, in der die Elemente nach nicht-steigenden Häufigkeiten sortiert sind. Sei m ein Vielfaches von n. Der worst case für SL ist, dass jedes Element gleich häufig angefragt wird. Dann entstehen für i=1..n ja m/n-mal Kosten i. Also ist OPT( ) i=1 n i m/n + = (n+1)m/2 + n(n-1)/2 Daraus folgt, dass c = A( )/OPT( ) 2n/(n+1) = 2-2/(n+1) Kapitel 251 n 2 m Aufwand für Umsortieren

52 Selbstorganisierende Liste 1.9 Satz: Transpose ist für keine Konstante c c-kompetitiv. Beweis: Betrachte die Liste 1,…,n und die Anfragefolge =(n,n-1,n,n-1,…,n,n-1) mit | |=m. Dann entstehen für Transpose Kosten von Transpose(s)=m n. Mit MTF entstehen auf derselben Folge Kosten von MTF(s)=n+n+2(m-2) = 2n+2m-4. Für n>m ist also c = Transpose(s)/OPT(s) Transpose(s)/MTF(s) m/ Kapitel 252

53 Selbstorganisierende Liste 1.10 Satz: FC ist für keine Konstante c c-competitiv. Beweis: Übung Kapitel 253

54 Kapitel 254 Suchstruktur Selbstorganisierende Liste (mit -Element) Problem bleibt: insert, delete und lookup kosten im worst case (n) Zeit Einsicht: Wenn lookup effizient zu implementieren wäre, dann auch alle anderen Operationen 19 1 … 3

55 Kapitel 255 Suchstruktur Idee: füge Navigationsstruktur hinzu, die lookup effizient macht 3 1 … 119 Navigationsstruktur

56 Kapitel 256 Binärer Suchbaum (ideal) lookup(14)

57 Kapitel 257 Binärer Suchbaum Suchbaum-Regel: Damit lookup Operation einfach zu imple- mentieren. k T1T1 T2T2 Für alle Schlüssel k´ in T 1 und k´´ in T 2 : k´ < k < k´´

58 Kapitel 258 Lookup(k) Operation Suchstrategie: Starte in Wurzel des Suchbaums Für jeden erreichten Knoten v: –Falls key(v) > k, gehe zum linken Kind von v, sonst gehe zum rechten Kind k T1T1 T2T2 Für alle Schlüssel k´ in T 1 und k´´ in T 2 : k´ < k < k´´

59 Kapitel 259 Binärer Suchbaum Formell: für einen Baumknoten v sei key(v) der Schlüssel in v d(v) die Anzahl Kinder von v Suchbaum-Regel: (s.o.) Grad-Regel: Alle Baumknoten haben zwei Kinder (sofern #Elemente >1) Schlüssel-Regel: Für jedes Element e in der Liste gibt es genau einen Baumknoten v mit key(v)=key(e).

60 Kapitel 260 Lookup(10)

61 Kapitel 261 Insert und Delete Operationen Strategie: insert(e): Erst lookup(key(e)) bis Element e´ in Liste erreicht. Falls key(e´)>key(e), füge e vor e´ ein und ein neues Suchbaumblatt für e und e´ mit key(e), so dass Suchbaum-Regel erfüllt. delete(k): Erst lookup(k) bis ein Element e in Liste erreicht. Falls key(e)=k, lösche e aus Liste und Vater v von e aus Suchbaum, und setze in dem Baumknoten w mit key(w)=k: key(w):=key(v)

62 Kapitel 262 Insert(5)

63 Kapitel 263 Insert(5)

64 Kapitel 264 Insert(12)

65 Kapitel 265 Insert(12)

66 Kapitel 266 Delete(1)

67 Kapitel 267 Delete(1)

68 Kapitel 268 Delete(14)

69 Kapitel 269 Delete(14)

70 Kapitel 270 Binärbaum Problem: Binärbaum kann entarten! Beispiel: Zahlen werden in sortierter Folge eingefügt Lookup benötigt (n) Zeit im worst case Lösung: Splay Baum

71 Kapitel 271 Splay-Baum Üblicherweise: Implementierung als interner Suchbaum (d.h. Elemente direkt integriert in Baum und nicht in extra Liste) Hier: Implementierung als externer Such- baum (wie beim Binärbaum oben)

72 Kapitel 272 Splay-Baum lookup(19) In Baum Zeiger auf Listenelement

73 Kapitel 273 Splay-Baum Ideen: 1.Im Baum Zeiger auf Listenelemente 2.Bewege Schlüssel von zugegriffenem Element immer zur Wurzel 2. Idee: über Splay-Operation

74 Kapitel 274 Splay-Operation Bewegung von Schlüssel x nach oben: Wir unterscheiden zwischen 3 Fällen. 1a. x ist Kind der Wurzel: AB C x y x A BC y zig

75 Kapitel 275 Splay-Operation Bewegung von Schlüssel x nach oben: Wir unterscheiden zwischen 3 Fällen. 1b. x ist Kind der Wurzel: AB C y xy A BC x zig

76 Kapitel 276 Splay-Operation Wir unterscheiden zwischen 3 Fällen. 2a. x hat Vater und Großvater rechts: AB C x y y B CD z zig-zig D z x A

77 Kapitel 277 Splay-Operation Wir unterscheiden zwischen 3 Fällen. 2b. x hat Vater und Großvater links: zig-zig AB C z y D x y B CD x z A

78 Kapitel 278 Splay-Operation Wir unterscheiden zwischen 3 Fällen. 3a. x hat Vater links, Großvater rechts: zig-zag AB C y x D z y A BC x z D

79 Kapitel 279 Splay-Operation Wir unterscheiden zwischen 3 Fällen. 3b. x hat Vater rechts, Großvater links: zig-zag AB C z x D y BC D x y A z

80 Kapitel 280 Splay-Operation Beispiel: x zig-zag Operation (3a)

81 Kapitel 281 Splay-Operation

82 Kapitel 282 Splay-Operation Beispiele: zig-zig, zig-zag, zig-zag, zig zig-zig, zig-zag, zig-zig, zig x x

83 Kapitel 283 Splay-Operation Baum kann im worst-case immer noch sehr unbalanciert werden! Aber amortisierte Kosten sind sehr niedrig

84 Kapitel 284 Splay-Operation lookup(k)-Operation: Laufe von Wurzel startend nach unten, bis k im Baumknoten gefunden (Abkürzung zur Liste) oder bei Liste angekommen k in Baum: rufe splay(k) auf Amortisierte Analyse: m Splay-Operationen auf beliebigem Anfangsbaum mit n Elementen (m>n)

85 Kapitel 285 Splay-Operation Gewicht von Knoten x: w(x) Baumgewicht von Baum T mit Wurzel x: tw(x)= y T w(y) Rang von Knoten x: r(x) = log(tw(x)) Potential von Baum T: (T) = x T r(x) 1.11 Lemma: Sei T ein Splay-Baum mit Wurzel u und x ein Knoten in T. Die amortisierten Kosten für splay(x,T) sind max. 1+3(r(u)-r(x)).

86 Kapitel 286 Splay-Operation Beweis von Lemma 1.11: Induktion über die Folge der Rotationen. r und tw : Rang und Gewicht vor Rotation r und tw: Rang und Gewicht nach Rotation 1. Fall: Amortisierte Kosten: 1+r(x)+r(y)-r(x)-r(y) 1+r(x)-r(x) da r(y) r(y) 1+3(r(x)-r(x)) da r(x) r(x) AB C x y x A BC y zig Laufzeit (# Rot.) Änderung von

87 Kapitel 287 Splay-Operation 2. Fall: Amortisierte Kosten: 2+r(x)+r(y)+r(z)-r(x)-r(y)-r(z) = 2+r(y)+r(z)-r(x)-r(y) da r(x)=r(z) 2+r(x)+r(z)-2r(x) da r(x) r(y) und r(y) r(x) AB C x y y B CD z zig-zig D z x A

88 Kapitel 288 Splay-Operation 2. Fall: Behauptung: Es gilt, dass 2+r(x)+r(z)-2r(x) 3(r(x)-r(x)) d.h. r(x)+r(z) 2(r(x)-1) AB C x y y B CD z zig-zig D z x A r(x) r(z) r(x)

89 Kapitel 289 Splay-Operation 2. Fall: Behauptung: Es gilt, dass r(x)+r(z) 2(r(x)-1) Ersetzungen: r(x) log x, r(z) log y, r(x) log 1. Betrachte die Funktion f(x,y)=log x + log y. Zu zeigen: f(x,y) -2 für alle x,y 0 mit x+y 1. AB C x y y B CD z zig-zig D z x A r(x) r(z) r(x)

90 Kapitel 290 Splay-Operation 1.12 Lemma: Die Funktion f(x,y)=log x + log y hat in dem Bereich x,y 0 mit x+y 1 im Punkt (½,½) ihr Maximum. Beweis: Da die Funktion log x streng monoton wachsend ist, kann sich das Maximum nur auf dem Geradensegment x+y=1, x,y 0, befinden. Neues Maximierungsproblem: betrachte g(x) = log x + log(1-x) Einzige Nullstelle von g(x) = 1/x - 1/(1-x) ist x=1/2. Für g(x)= -(1/x 2 + 1/(1-x) 2 )) gilt g(1/2) < 0. Also hat Funktion f im Punkt (½,½) ihr Maximum.

91 Kapitel 291 Splay-Operation 2. Fall: Behauptung: Es gilt, dass r(x)+r(z) 2(r(x)-1) Ersetzungen: r(x) log x, r(z) log y, r(x) log 1. Es folgt: f(x,y)=log x + log y -2 für alle x,y 0 mit x+y 1. Die Behauptung ist also korrekt. AB C x y y B CD z zig-zig D z x A r(x) r(z) r(x)

92 Kapitel 292 Splay-Operation 3. Fall: Amortisierte Kosten: 2+r(x)+r(y)+r(z)-r(x)-r(y)-r(z) 2+r(y)+r(z)-2r(x) da r(x)=r(z) und r(x) r(y) 2(r(x)-r(x)) denn… zig-zag AB C y x D z y A BC x z D

93 Kapitel 293 Splay-Operation 3. Fall: …es gilt: 2+r(y)+r(z)-2r(x) 2(r(x)-r(x)) 2r(x)-r(y)-r(z) 2 r(y)+r(z) 2(r(x)-1) analog zu Fall 2 zig-zag AB C y x D z y A BC x z D

94 Kapitel 294 Splay-Operation Beweis Lemma 1.11: Induktion über die Folge der Rotationen. r: Rang vor Rotation r: Rang nach Rotation Für jede Rotation ergeben sich amortisierte Kosten von max. 1+3(r(x)-r(x)) (Fall 1) bzw. 3(r(x)-r(x)) (Fälle 2 und 3) Aufsummierung der Kosten ergibt mit Wurzel u max. 1 + Rot. 3(r(x)-r(x)) = 1+3(r(u)-r(x))

95 Kapitel 295 Splay-Operation Baumgewicht von Baum T mit Wurzel x: tw(x)= y T w(y) Rang von Knoten x: r(x) = log(tw(x)) Potential von Baum T: (T) = x T r(x) 1.13 Lemma: Sei T ein Splay-Baum mit Wurzel u und x ein Knoten in T. Die amortisierten Kosten für splay(x,T) sind max. 1+3(r(u)-r(x)) = 1+3 log (tw(u)/tw(x)) Korollar: Sei W= x w(x) und w i das Gewicht von k i in i-tem lookup. Für m lookup-Operationen sind die amor- tisierten Kosten O(m+3 i=1 m log (W/w i )).

96 Kapitel 296 Splay-Baum 1.15 Satz: Die Laufzeit für m lookup Operationen in einem n-elementigen Splay-Baum T ist höchstens O(m+(m+n)log n). Beweis: Sei w(x) = 1 für alle Schlüssel x in T. Dann ist W=n und r(x) log W = log n für alle x in T. Erinnerung: für eine Operationsfolge F ist die Laufzeit T(F) A(F) + (s 0 ) für amortisierte Kosten A und Anfangszustand s 0 (s 0 ) = x T r 0 (x) n log n Aus Korollar 1.14 ergibt sich Theorem 1.15.

97 Kapitel 297 Splay-Baum Angenommen, wir haben eine Wahrscheinlichkeitsvertei- lung für die Suchanfragen. p(x) : Wahrscheinlichkeit für Schlüssel x H(p) = x p(x) log(1/p(x)) : Entropie von p 1.16 Satz: Die Laufzeit für m lookup Operationen in einem n- elementigen Splay-Baum T ist höchstens O(m H(p) + n log n). Beweis: Folgt aus Korollar 1.14 mit w(x) = n p(x) für alle x. Bemerkung: Laufzeit (m H(p)) für jeden statischen binären Suchbaum! Es ist aber seit der Enwicklung von Splay Bäumen vor 25 Jahren immer noch ein offenes Problem, ob diese konstant kompetitiv auch gegenüber dynamischen binären Suchbäumen sind.

98 Kapitel 298 Splay-Baum Operationen Bemerkung: Die amortisierte Analyse kann erweitert werden auf insert und delete, wenn diese wie folgt implementiert sind. insert(e): wie im binären Suchbaum splay-Operation, um key(e) in Wurzel zu verschieben delete(k): wie im binären Suchbaum

99 Kapitel 299 Fragen?


Herunterladen ppt "10.11.2013Kapitel 21 Methoden des Algorithmenentwurfs Kapitel 2.1: Deterministische Online Algorithmen Christian Scheideler SS 2009."

Ähnliche Präsentationen


Google-Anzeigen