Algorithmik mit Python

Transkript

1 Algorithmik mit Python Prof. Dr. Tobias Häberlein Hochschule Albstadt-Sigmaringen Studiengang Kommunikations- und Softwaretechnik Leipzig, T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

2 Überblick Implementierung von Algorithmen Sortieren Insertion-Sort Quicksort 3 Suchen Heaps Skip-Listen Bloomfilter Suchmaschinen 4 Graphen Grundlagen Kürzeste Wege Minimaler Spannbaum 5 Schwere Probleme Lösung des Traveling Salesman Problems Greedy-Heuristiken zur Lösung des TSP T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

3 Implementierung von Algorithmen Rekursion Eine Funktion heißt rekursiv, wenn Sie sich selbst ein oder mehrmals aufruft. Pro: Oft einfacher zu implementieren, als iterative Ansätze. Con: I. A. mehr Speicherverbrauch def faciter(n): erg = 3 for i in range(,n+) 4 erg = erg*i 5 return erg def facrec(n): if n==0: 3 return 4 else: 5 return n*fac(n-) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

4 Implementierung von Algorithmen Rekursive vs. Iterativ? Kochrezept Rekursionsabbruch: Was ist der einfache Fach (Größe n = 0 oder n = ). Rekursionsschritt: Gedankentrick: Angenommen, Aufgabe für alle kleineren Probleme gelöst wie kann man dann aus den Lösungen der kleineren Aufgaben, die Lösung der Gesamtaufgabe konstruieren. def rekalg(x): if len(x) is kleingenug: 3 return loesung(x) 4 else: y = rekalg(x) 7 y = rekalg(x) loesung = kombiniere(y,y 0 return loesung T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

5 Implementierung von Algorithmen Aufgaben: Rekursion () Aufgabe Definieren Sie die Funktion sum(n), die die Summe der Zahlen von bis n berechnen soll, rekursiv. Definieren Sie die Funktin len(lst), die die Länge der Liste lst berechnen soll, rekursiv. Aufgabe Implementieren Sie die Funktion ins(x,lst), die die Liste aller möglichen Einfügungen des Elements x in die Liste lst zurückliefert. Beispielanwendung: >>> ins(,[,3,4,5]) >>> [[,,3,4,5], [,,3,4,5], [,3,,4,5], [,3,4,,5], [,3,4,5,] Tipp: Das geht über eine rekursive Implementierung. Es empfiehlt sich auch die Verwendung einer Listenkomprehension. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

6 Implementierung von Algorithmen Aufgaben: Rekursion ()... und noch etwas schwieriger: Aufgabe 3 Implementieren sie eine rekursive Funktion perms(lst), die die Liste aller Permutationen der als Argument übergebenen Liste lst zurückliefert. Tipp: Verwenden Sie die eben definierte Funktion ins. Beispielanwendung: >>> perms([,,3]) >>> [[,,3],[,3,],[,,3],[,3,],[3,,],[3,,]] Aufgabe 4 Implementierung Sie die rekursive Funktion choice(lst,k), die eine Liste aller k-elementigen Teil mengen der Elemente aus lst zurückliefert. Beispielanwendung: >>> choice([,,3],) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

7 Implementierung von Algorithmen Rekursiv gehts einfacher Die rekursive Implementierung vieler Probleme ist viel einfacher! Beispiel: Zeichnen der Striche auf einem Lineal Rekursive Implementierung: from graphics import * linealcanv = GraphWin("Ein Lineal",000,50) 3 4 def strich(x,h): 5 '''Zeichne Strich an Position x mit Laenge h''' 6 l = Line(Point(x,0),Point(x,h)) 7 l.draw(linealcanv) 8 9 def lineal(l,r,h): 0 ''' Zeichne Lineal zwischen Pos l und r laengster Strich (in der Mitte) hat Hoehe h'''... T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

8 Implementierung von Algorithmen Aufgabe 5 Zeichnen Sie durch eine rekursiv definierte Python-Funktion und unter Verwendung der graphics-bibliothek folgenden Stern: Aufgabe 6 Schreiben Sie eine rekursive Prozedur baum(x,y,b,h) zum Zeichnen eines (binären) Baumes derart, dass die Wurzel sich bei (x,y) befindet, der Baum b breit und h hoch ist. Definieren Sie hierzu eine Python-Prozedur line(x,y,x,y), die eine Linie (x,y) zu (x,y) zeichnet. Beispiel für die Ausgabe von baum(0,0,6,4). 3 4 (0,0) 6 T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

9 Implementierung von Algorithmen Destruktiv vs. Nicht-Destruktiv list.sort() ist destruktiv: >>> l = list('hallo') >>> l.sort() # l wird veraendert >>> l ['a', 'h', 'l', 'l', 'o'] Vor-/Nachteile Pro Nicht-Destruktiv: sorted(list) ist nicht-destruktiv: >>> l = list('hallo') >>> sorted(l) # l unveraendert ['a', 'h', 'l', 'l', 'o'] Jeder destruktive Update verändert internen Zustand des Programms. Viele Zustände viele Abfragen viele mögliche Fehler Wenige Zustände besserer Überblick weniger mögliche Fehler Con Nicht-Destruktiv:...?... T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

10 Sortieren Insertion-Sort Insertion-Sort Funktionsweise So sortiert der Kartenspieler: Sukzessive werden Karten vom Stapel in die schon sortierten Karten auf der Hand eingefügt.. [53,6,63,94,56,8,7,44,70] 5. [6,53,56,63,94,8,7,44,70]. [6,53,63,94,56,8,7,44,70] 6. [6,8,53,56,63,94,7,44,70] 3. [6,53,63,94,56,8,7,44,70] 4. [6,53,63,94,56,8,7,44,70] 7. [6,8,53,56,63,7,94,44,70] 8. [6,8,44,53,56,63,7,94,70] Ergebnis: [6,8,44,53,56,63,70,7,94] T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

11 Sortieren Insertion-Sort Insertion-Sort Implementierung Wir teilen auf ins das Einfügen: def insatrightpos(alst, key): return [x for x in alst if x <=key] +[key] + 3 [x for x in alst if x>key] und das eigentliche Sortieren rekursiv implementiert. def insertionsort(alst): if len(alst)<=: return alst 3 else: return... Aufgabe 7 Ersetzen sie die... -Stelle in obigem Listing durch den notwendigen rekursiven Aufruf. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

12 Sortieren Insertion-Sort Insertion-Sort Implementierung in-place def insertionsort(lst): for j in range(,len(lst)): 3 key = lst[j] 4 i = j- 5 while i >= 0 and lst[i] > key: 6 lst[i+] = lst[i] 7 i = i - 8 lst[i+] = key Zwar schneller, aber schwieriger zu implementieren! T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

13 Sortieren Quicksort Quicksort Funktionsweise + Implementierung Wähle beliebiges Element lst j mit 0 j n aus (Pivot-Element). Zerteile lst in lst l (alle Elemente < lst j ) und lst r (alle Elemente lst j ) lst l und lst r werden rekursiv sortiert. Die rekursiv sortierten Teillisten werden einfach zusammengehängt. def quicksort(lst): if len(lst)<=: return lst # Rekursionsabbruch 3 pivot = lst[0] 4 lst_l = [a for a in lst[:] if a <= pivot] 5 lst_r = [a for a in lst[:] if a > pivot] 6 return... Aufgabe 8 Vervollständigen Sie die Implementierung von Quicksort an der... -Stelle. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

14 Sortieren Quicksort Quicksort Implementierung in-place Schneller, aber schwieriger zu implementieren! Die in-place-partitionierung def partitionip(lst,l,r): pivot=lst[l] 3 i=l- 4 j=r+ 5 while True: 6 while True: 7 j=j- 8 if lst[j]<=pivot: break 9 while True: 0 i=i+ if lst[i]>=pivot: break if i<j: 3 lst[i],lst[j]=lst[j],lst[i] 4 else: 5 return j Das eigentliche in-place-sortieren. def quicksortip(lst,l,r): if r>l: 3 i= partitionip(lst,l,r) 4 quicksortip(lst,l,i) 5 quicksortip(lst,i+,r) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

15 Suchen Heaps Die Heap-Struktur Ein Max-Heap ist ein fast vollständiger Binärbaum. Max-Heap-Eigenschaft: Der Schlüssel eines Knotens ist größer als die Schlüssel seiner beiden Kinder Ein Max-Heap: 3 Ein Min-Heap: Der Max-Heap kann repräsentiert werden als: [None,3,8,,9,7,9,5,,4,3,6] T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

16 Suchen Heaps Heap Aufgaben Implementierung Aufgabe 9 Implementieren Sie die Funktion leftchild(heap,i), die den Wert des linken Kindes von heap[i] zurückgibt. Gibt es kein solches, soll None zurückgeliefert werden. Implementieren Sie die Funktion rightchild(heap,i) entsprechend. 3 Implementieren Sie eine Funktion father(heap,i), die als Argument einen Heap heap und einen Index i übergeben bekommt und den Wert des Vaters von heap[i] zurückliefert. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

17 Suchen Heaps Heaps Einfügen Für viele Anwendungen wichtig: Effizientes Extrahieren des größten (kleinsten) Elements. Optimal dafür: Heaps! Einfügen: Aufgabe 0 Vervollständigen Sie den folgenden Code zur Implementierung der Einfüge-Operation in Heaps. def inserth(heap, x): heap.append(x) 3... T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

18 Suchen Heaps Heaps Min-Extrakt T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

19 Suchen Heaps Heaps Min-Extrakt-Implementierung def minextrakt(heap): returnval=heap[] 3 n=len(heap)- 4 heap[]=heap[n] # letztes Element an die Wurzel 5 del(heap[n]) 6 n-= # n soll weiterhin auf das letzte Element zeigen 7 i= 8 while i<=n/: 9 j=*i 0 if j<n and heap[j]>heap[j+]: j+= # waehle kleineres der beiden if heap[i]<=heap[j]: break heap[i],heap[j]=heap[j],heap[i] 3 i=j 4 return returnval Laufzeit: O(log n) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

20 Suchen Heaps Heaps build-heap-implementierung Hintere Hälfte der Liste (also lst[len(lst)/:]): Sammlung von len(lst)/ Heaps; noch über den vorderen Teil der Liste laufen und alle verletzten Heap-Bedingungen wiederherstellen. def buildheap(lst): # Es muss lst[0]==none gelten for i in range(len(lst)/,0,-): 3 minheapify(lst,i) Laufzeit: O(n) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

21 Suchen Heaps Heaps in Python Die Standard-Modul heapq implementiert Heaps. heapq.heapify(lst): Transformiert die Liste lst in-place in Min-Heap; heapq.heappop(lst): Enfernt kleinestes Element aus Heap lst; heapq.heappush(lst,x): Fügt ein neues Element x in Heap lst ein; T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

22 Suchen Skip-Listen Skip-Listen Beispiel: Sind ähnlich zu verketteten Listen, außer, dass ein Element mehrere Vorwärtszeiger haben kann Für Skip-Liste muss gelten: Wkeit, dass zufällig gewählter Eintrag i Vorwärtszeiger hat: p i ( p) Randomisierte Impl. from random import random p =... # Wkeit mit 0<p< 3 def randheight(): 4 i=0 5 while random()<=p: i+= 6 return min(i,maxheight) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

23 Suchen Skip-Listen Skip-Listen Implementierung class SLEntry(object): def init (self, key, ptrs=[], val=none): 3 self.key = key ; self.ptrs = ptrs ; self.val = val 4 5 class SkipList(object): 6 def init (self): 7 self.tail = SLEntry(Infty) 8 self.head = SLEntry(None,[self.tail]*(MaxHeight+)) 9 self.height = - Eine leere Skipliste hat ein tail Ein Ende mit key= head Ein Kopf mit allen Vorwärtszeigern auf tail T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

24 Suchen Skip-Listen Skip-Listen Suche Suche nach einem Eintrag mit Schlüssel key: class SkiptList(object):... 3 def search(self, key): 4 x = self.head 5 for i in range(self.height,-,-): 6 while x.ptrs[i].key < key: x = x.ptrs[i] 7 x = x.ptrs[0] 8 if x.key == key: return x.val 9 else: return None T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

25 Suchen Skip-Listen Skip-Listen Einfügen 7 Wähle Höhe i durch Zufallsentscheidung (randheight) Es müssen i Zeiger anderer Elemente umgebogen werden. updateptrs[3] updateptrs[] updateptrs[] 44 updateptrs[0] Der i-te Vorwärtszeiger von updateptrs[i] muss umgebogen werden Aufgabe Implementieren Sie eine Methode insert(key,val) der Klasse SkipList T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

26 Suchen Skip-Listen Skip-Listen Aufgaben () Aufgabe Implementieren Sie die Funktion str, so dass Skip-Listen folgendermaßen ausgegeben werden: >>> print skiplist >>> [ (30 ), (33 4), (40 3), (77 ), (98 ), (09 ), (93 3) ] Ausgegeben werden soll also der Schlüssel jedes Elements zusammen mit der Höhe des Elements. Aufgabe 3 Schreiben Sie eine Methode keys(), die eine Liste der in der Skip-Liste gespeicherten Schlüsselwerte zurückliefert. Schreiben Sie eine Methode vals(), die eine Liste der in der Skip-Liste gespeicherten Werte zurückliefert. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

27 Suchen Skip-Listen Skip-Listen Aufgaben () Aufgabe 4 Oft wird eine effiziente Bestimmung der Länge einer Skip-Liste benötigt. Erweitern Sie die Klasse SkipList um ein Attribut length, passen Sie entsprechend die Methoden insert und delete an und geben Sie eine Implementierung der Methode len an, so dass die len-funktion auf Skip-Listen anwendbar ist. Aufgabe 5 Schreiben Sie eine Funktion numheights(h), die die Anzahl der Elemente mit Höhe n zurückliefert. Schreiben Sie eine Funktion avgheight(s), die die durchschnittliche Höhe eines Elementes der Skip-Liste s berechnet. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

28 Suchen Bloomfilter Bloomfilter Grundlegendes Sehr platz- und zeiteffiziente Möglichkeit des Membership-Tests. Bloomfilter sind probabilistisch: Möglichkeit falsch-positiver Antworten. Datensatz in Bloomfilter Antwort immer korrekt! Datensatz nicht in Bloomfilter Antwort nicht immer korrekt! lang- samer Speicher Eine Anwendung unter vielen: w S? Bloomfilter nein ja y S? nein ja x S? ja nein z S? T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

29 Suchen Bloomfilter Bloomfilter Funktionsweise Bsp: Einfügen von eine h 0 (eine) = 3, h 0 (Einführung) =, h 0 (Informatik) = 6 h (eine) =, h (Einführung) = 8, h (Informatik) = false false false false false false false false false false Einfügen von Einführung = h (eine) = h 0 (eine) false true false true false false false false false false = h 0 (Einführung) false true false true false false false false true false Einfügen von Informatik false true false true false false true true true false = h (Einführung) = h 0 (Informatik) = h (Informatik) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

30 Suchen Bloomfilter Bloomfilter Implementierung class BloomFilter(object): def init (self, h, m): 3 self.k = len(h) ; self.h = h 4 self.a = [False]*m 5 self.m = m 6 7 def insert(self,x): 8... # Siehe Aufgabe 9 def elem(self,x): 0... # Siehe Aufgabe Aufgabe 6 Implementieren Sie insert und elem. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

31 Suchen Suchmaschinen Suchmaschinen Aufbau einer Suchmaschine Web Datenbank Dateisystem Crawler Indexer Index Suchanfrage Bearbeitung GUI Der invertierte Index... das Herz jeder Suchmaschine! Liste aller Wörter... Hashtabelle Heap Heapsort Hornerschema Insertion Sort... [430,0,344,98,...] T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57 [0,7,...] [0,...]

32 Suchen Suchmaschinen Implementierung def crawl(self, path): class Index(object): def tupl(x,y): return (x,y) def init (self, path=''): 3 for dirpath, dirnames, filenames \ 3 self.docid = 0 4 in os.walk(path): 4 self.ind = {} 5 for file in filenames: 5 self.docind = {} 6 f = os.path.join(dirpath, file) 6 if path!='': self.crawl(path) 7 if istxt(f): 8 self.addfile(f) def addfile(self, file): def tupl(x,y): return (x,y) 3 self.docind[self.docid] = file 4 filehandle = open(file) 5 filecont = filehandle.readlines() ; filehandle.close() 6 filecont = map(tupl, xrange(0,len(filecont)), filecont) 7 words = [(word.lower(),pos) for (pos,line) in filecont 8 for word in line.split() 9 if len(word) >=3 and word.isalpha() ] 0 for word,pos in words: self.toindex((word,pos), self.docid) self.docid+= T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

33 Suchen Suchmaschinen Aufgaben Aufgabe 7 Implementieren Sie die fehlende Methode toindex((word,pos),docid) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

34 Graphen Grundlagen Repräsentation von Graphen Der folgende Graph... mit: 5 G = (V, E) mit V = {,, 3, 4, 5}, 3 4 E = {(, ), (, ), (, 3), (, 3), (, 4), (3, 4), (4, 5)}... kann repräsentiert werden als... Adjazenzmatrix Adjazenzliste {, 3, 4} {, 3} {4} {5} {} T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

35 Graphen Grundlagen Repräsentation in Python class Graph(object): def init (self,n): 3 self.vertices = [] 4 self.numnodes = n 5 for i in range(0,n+): 6 self.vertices.append({}) self.vertices ist die Adjazenzliste deren Einträge dict-objekte sind die adjanzente Knoten (inkl. evtl. Gewichte) enthalten. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

36 Graphen Grundlagen Wichtige Methoden () Aufgabe 8 Implementieren Sie die Graph-Methoden addedge, isedge, G, V, E und füllen sie hierzu die Lücken in folgendem Listing: class Graph(object):... 3 def addedge(self,i,j,weight=none): def isedge(self,i,j): def G(self,i): def V(self): 0... def E(self):... T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

37 Graphen Grundlagen Wichtige Methoden () Aufgabe 9 Erweitern Sie die Klasse Graph um die Methode Graph.w(i,j), die das Gewicht der Kante (i, j) zurückliefert (bzw. None, falls die Kante kein Gewicht besitzt). Aufgabe 0 Erweitern Sie die Klasse Graph um die folgenden Methoden: Eine Methode Graph.isPath(vs), die eine Knotenliste vs übergeben bekommt und prüft, ob es sich hierbei um einen Pfad handelt. Eine Methode Graph.pathVal(vs), die eine Knotenliste vs übergeben bekommt. Handelt es sich dabei um einen gültigen Pfad, so wird der Wert dieses Pfades (d. h. die Summe der Gewichte der Kanten des Pfades) zurückgeliefert. Andernfalls soll der Wert (in Python: float('inf')) zurückgeliefert werden. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

38 Graphen Kürzeste Wege Algorithmus von Warshall Berechnet die kürzesten Wege zwischen allen Knotenpaaren. Berechnungsschema: Berechne W 0 : alle kürzesten Wege mit keinen Zwischenknoten Aus W k berechnet W k : alle kürzesten Wege mit Zwischenknoten {,..., i} 3 Lösung: W n Schritt von W k nach W k : k Pfad mit Knoten aus {,..., k} i j Pfad mit Knoten aus {,..., k } Es gilt: W k [i, j] := min{ W k [i, j], W k [i, k] + W k [k, j] } T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

39 Graphen Kürzeste Wege Warshall Implementierung def warshall(graph): n = graph.numnodes+ 3 W = [ [graph.w(i,j) for j in graph.v()] for i in graph.v() ]# W_ W: Adjazenzmatrix des Graphen, also W 0. Aufgabe Vervollständigen Sie die Implementierung des Warshall-Algorithmus, d. h. ersetzen sie die...-stelle durch Code, der Sukzessive W, W,..., W n berechnet. Aufgabe Was ist die Laufzeit des Warshall-Algorithmus? D. h. wie viele Berechnungsschritte in der O-Notation benötigt der Warshall-Algorithmus zur Berechnung der kürzesten Wege eines Graphen mit n Knoten? T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

40 Graphen Kürzeste Wege Der Dijkstra-Algorithmus Berechnet nicht alle Abstände zwischen allen Knoten, sondern berechnet ausgehend von einem Knoten v die Abstände l[u] (Länge der kürzesten Wege) zu allen Knoten u V. Edsger Dijkstra (930-00) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

41 Graphen Kürzeste Wege Der Dijkstra-Algorithmus Funktionsweise Dijkstra ist greedy: Knoten werden sukzessive abgehakt : Es kommt immer derjenige Knoten an die Reihe, der momentan den geringsten l-wert hat. Es wird versucht, die Abstände aller seiner Nachbarn zu verbessern. a b c d 5 l[u]=0 u f e g 8 W = {a, b, c, d, e, f, g, u} l[c]= l[u]=0 l[f ]= a c u f b d e g 0 8 l[d]=4 l[e]=7 l[g]=3 W = {a, b, c, d, e, g} l[c]=9 l[u]=0 l[f ]= a c u f b d e g 0 8 l[b]=4 l[d]=4 l[e]=6 l[g]=3 W = {a, b, c, e} l[c]= l[u]=0 l[f ]= a c u f b d e g 0 8 l[d]=4 l[e]=7 l[g]=5 W = {a, b, c, d, e, f, g} l[c]= l[u]=0 l[f ]= a c u f b d e g 0 8 l[d]=4 l[e]=7 l[g]=3 W = {a, b, c, d, e} l[a]= l[c]=9 l[u]=0 l[f ]= a c u f b d e g 0 8 l[b]=3 l[d]=4 l[e]=6 l[g]=3 W = {a, b} T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

42 Graphen Kürzeste Wege Der Dijkstra-Algorithmus Implementierung def dijkstra(u,graph): n = graph.numnodes 3 l = { u : 0 } ; W = graph.v() 4 F = [] ; k = {} 5 for i in range(0,n): 6 lv,v = min([ (l[lk],lk) for lk in l.keys() if lk in W ]) 7 W.remove(v) 8 if v!=u: F.append(k[v]) return l,f W: Menge der noch zu bearbeitenden Knoten k[v]: Vorgängerknoten von v auf kürzestem Weg nach v (vorläufig). F: Vorgängerknoten von v auf kürzestem Weg nach v (final). Aufgabe 3 Vervollständigen Sie die Implementierung des Dijkstra-Algorithmus. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

43 Graphen Minimaler Spannbaum Minimaler Spannbaum Kruskal-Algorithmus Spannbaum ˆ= Teilgraph G T = (V T, E T ) eines ungerichteten zusammenhängenden Graphen G = (V, E), der ein Baum (also kreisfrei und zusammenhängend) ist. a b c d e f g h a b c d e f g h a b c d e f g h a b c d e f g h a b c d e f g h Anwendungen: Möglichst preisgünstiges zusammenhängiges Netzwerk. Vermeidung von redundanten Sendepfaden. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

44 Graphen Minimaler Spannbaum Kruskal-Algorithmus Funktionsweise Algorithmus ist greedy: In jedem Schritt wird immer genau eine Kante hinzugenommen, für die gilt: minimales Gewicht + ohne dass Kreis entsteht.... solange, dass bis dies nicht mehr geht. Minimaler Spannbaum gefunden T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

45 Graphen Minimaler Spannbaum Kruskal-Algorithmus Implementierung def kruskal(graph): alledges = [(graph.w(i,j),i,j) for i,j in graph.e_undir()] 3 alledges.sort(reverse=true) # absteigend 4 spanntree = [] 5 while len(spanntree) < len(graph.v())- and alledges!=[]: 6 (w,i,j) = alledges.pop() 7 if not buildscircle(spanntree,(i,j)): 8 spanntree.append((i,j)) 9 return spanntree Aber: Sortieren aller Kanten:O( E log E ) ineffizienter als Verwendung eines Heap: O( E + V log E ) Implementierung von buildscircle? T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

46 Graphen Minimaler Spannbaum Union-Find-Datenstruktur Bietet effiziente Implementierung der Mengenoperationen Vereinigung (zweier Mengen) union(x,y) x und y eindeutige Repräsentanten einer Menge... Suche eines Elementes in einer Menge find(x) liefert eindeutigen Repräsentanten der Menge, die x enthält. Gleichzeitig: Effizienter Test, ob durch das Hinzufügen einer Kante (i, j) ein Kreis entsteht (a):find(3) find(6) (b):find(8) find(9) (c):find(7) find(9) (d):find(4) find(8) (e):find(5) find(6) (f):find() find(3) (g):find() find() (h):find(6) find(7) T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, /

47 Graphen Minimaler Spannbaum Union-Find im Kruskal-Algorithmus Kante {i, j} hinzufügen? Zwei Fälle: Falls find(i)==find(j): Nicht hinzufügen! Denn: i und j befinden sich in derselbsen Zusammenhangskomponente. i und j verbunden. Es würde ein Kreis entstehen. Falls find(i)!=find(j): Hinzufügen! Denn: i und j bisher nicht verbunden. Es entsteht kein Kreis T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

48 Graphen Minimaler Spannbaum Union-Find Implementierung self.parent: Speichert für jeden Knoten den Elternknoten. self.parent[i]== 0 gdw. i hat keinen Elternknoten. find(x): Liefert Wurzel des Baumes, der x enthält. union(x,y): fügt zwei Bäume zusammen, indem die Wurzel des einen Baumes (der y enthält) als Kind unter die Wurzel des anderen Baumes (der x enthält) gehängt wird. class UF(object): def init (self,n): 3 self.parent = [0]*n 4 5 def find(self,x): 6 while self.parent[x] > 0: 7 x = self.parent[x] 8 return x 9 0 def union(self,x,y): self.parent[y] = x T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

49 Graphen Minimaler Spannbaum Union-Find Aufgaben/Verbesserungen Aufgabe 4 Implementieren Sie für die Klasse UF die str-funktion, die ein Objekt der Klasse in einen String umwandelt. Beispiel-Ausgabe: >>> uf = UF(0) >>> uf.union(,) ; uf.union(,3) ; uf.union(5,6) ; uf.union(8,9) >>> str(uf) >>> '{,, 3} {4} {5, 6} {7} {8, 9} ' Eine sehr nützliche Verbesserung: Balancierung! Aufgabe 5 Verbessern Sie die Union-Find-Impl. indem Sie auf die Balancierung der Bäume achten. find(x) sollte nur dann als Kind unter die Wurzel von find(y) gehängt werden, wenn Höhe(find(x)) < Höhe(find(y)); andernfalls: find(y) unter die Wurzel von find(x) hängen. Tipp: (Negative) Höhe in der Wurzel speichern. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

50 Graphen Minimaler Spannbaum Union-Find Aufgaben/Verbesserungen Eine weitere sehr nützliche Verbesserung: Pfad-Komprimierung! Aufgabe 6 find(x) findet immer den Pfad von x zur Wurzel. füge danach Direktkante von x zur Wurzel ein.... und auch Direktkanten für alle Knoten auf dem Pfad. Implementieren Sie diese Verbesserung. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

51 Graphen Minimaler Spannbaum Kruskal-Algorithmus Aufgabe Aufgabe 7 Implementieren Sie den Kruskal-Algorithmus unter Verwendung der Union-Find-Datenstruktur. Aufgabe 8 Man kann den minimalen Spannbaum auch finden, indem man genau umgekehrt wie der Kruskal-Algorithmus vorgeht: Man beginne mit allen im Graphen enthaltenen Kanten und entfernt Kanten mit dem momentan höchsten Gewicht nur dann aber, wenn man dadurch den Graphen nicht auseinander bricht. Geben Sie eine Implementierung des umgekehrten Kruskal-Algorithmus an. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

52 Schwere Probleme Lösung des Traveling Salesman Problems Das TSP-Problem Bremen Hamburg TSP ˆ= Travelling Salesman Problem. Gegeben: n Städte Gesucht: Kürzeste Rundtour, die jede Stadt genau einmal besucht. Duisburg Essen Bochum Dortmund Düsseldorf Wuppertal Köln Bonn Hannover Bielefeld Frankfurt am Main Mannheim Stuttgart Nürnberg Berlin Leipzig Dresden München Lösung des TSP für die 0 größten Deutschen Städte. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

53 Schwere Probleme Lösung des Traveling Salesman Problems TSP-Lösung durch Ausprobieren Lösung des TSP ˆ= Permutation der n Städte. Durchprobieren aller Permutationen perms(graph.v()) Aufgabe 9 Implementieren Sie den Brute-Force-Lösungsansatz Durchprobieren aller Permutationen, um die optimale Lösung des TSP zu finden und vervollständigen Sie hierzu den folgenden Code: def TSPBruteForce(graph): nodelist = graph.v()[:] 3 return... Tipp: Verwenden Sie graph.pathval um die Länge eines Pfades zu bestimmen. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

54 Schwere Probleme Lösung des Traveling Salesman Problems TSP-Lösung durch Dynamische Programmierung Fürs TSP gilt das sog. (Bellmannsche) Optimalitätsprinzip: Eine optimale Lösung setzt sich zusammen aus kleineren optimalen Lösungen. Lösung durch Dynamische Programmierung möglich: Zuerst: Lösungen der kleinen Teilprobleme berechnen und Zwischenergebnisse in Tabelle speichern. Bei Berechnung der größeren Teilprobleme: Auf Tabelle zurückgreifen. Fürs TSP gilt: T (i, S): Wert der kürzesten Tour, startend bei Knoten i, die alle Knoten aus S genau einmal besucht und bei Knoten endet Dann gilt: ( ) T (i, S) = min w(i, j) + T (j, S \ {j}) j S T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

55 Schwere Probleme Lösung des Traveling Salesman Problems TSP-Lösung durch Dynamische Programmierung () Die Formel ( ) T (i, S) = min w(i, j) + T (j, S \ {j}) j S Entspricht in Python (T ist Dict-Objekt): T[(i,S)] = min( graph.w(i,j)+t[(j,diff(s,[j]))] for j in S) def tsp(graph): n = graph.numnodes 3 T = {} 4 for i in range(,n+): T[(i,())] = graph.w(i,) 5 for k in range(,n-): 6... Aufgabe 30 Vervollständigen Sie die Implementierung und ersetzen Sie die... durch den entsprechenden Code. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

56 Schwere Probleme Greedy-Heuristiken zur Lösung des TSP Nearest-Neighbor-Heuristik Von der aktuellen Stadt aus wählt man einfach immer die nächste aus. Aufgabe 3 Implementieren Sie die Nearest-Neighbor-Heuristik für das Traveling- Salesman-Problem und testen Sie diese durch Berechnung der kürzesten Tour durch die größten 0 deutschen Städte.... größten 40 deutschen Städte. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57

57 Schwere Probleme Greedy-Heuristiken zur Lösung des TSP Insertion-Heuristiken Man beginnt mit sehr kurzer ( Städte) Tour und fügt sukzessive weitere Knoten hinzu. Folgende Strategien: Nearest Insertion : Als nächtes wird derjenige Knoten hinzugefügt, der zur momentanen Tour den geringsten Abstand hat. Farthest Insertion : Als nächtes wird derjenige Knoten hinzugefügt, der zur momentanen Tour den größten Abstand hat. Random Insertion : Als nächtes wird zufällig ein noch nicht in der Tour befindlicher Knoten zur Tour hinzugfügt. Aufgabe 3 Implementieren Sie die Nearest/Farthest/Random-Insertion-Heuristik. T. Häberlein HS AlbSig Algorithmik mit Python Leipzig, / 57