Entwurf von Algorithmen

Transkript

1 Kapitel : Entwurf von Algorithmen Einführung in die Informatik Wintersemester /8 Prof. Bernhard Jung Übersicht Einleitung: Entwurf von Algorithmen Entwurfsprinzip: Schrittweise Verfeinerung Entwurfsprinzip: Einsatz von Algorithmenmustern Algorithmenmuster: Greedy Beispiel: optimales Kommunikationsnetz Exkurs: Listen (und Matrizen) in Python Algorithmenmuster: Backtracking Beispiel: Kürzeste Rundreise Beispiel: 8-amen-Problem Literatur G. Saake & K.-U. Sattler. Algorithmen und atenstrukturen. dpunkt Lehrbuch..

2 Einleitung: Entwurf von Algorithmen Programmieren ist konstruktive und kreative Tätigkeit Erstellung eines optimalen Algorithmus i.a. nicht automatisierbar Trotzdem existieren verschiedene typische Muster für Algorithmen, die in Praxis oft Anwendung finden aber fallspezifisch anzupassen sind schon bekanntes Muster: divide-and-conquer lokales Optimum z.b. Algorithmenmuster für Optimierungsprobleme, u.a. greedy-algorithmen effizient, liefern lokales Optimum Backtracking nicht so effizient, liefert globales Optimum globales Optimum Entwurfsprinzip: Schrittweise Verfeinerung Beim Entwurf von Algorithmen beschreibe Grobverfahren in abstraktem Pseudocode dabei Zerlegung in Teilaufgaben Verfeinere Pseudocode und ersetze diesen nach und nach durch detaillierten Pseudocode wiederhole bis letztlich Algorithmus in Programmiersprachencode beschrieben ist Top-own-Entwurf

3 Entwurfsprinzip: Schrittweise Verfeinerung Beispiel Grobverfahren. Wasser kochen. Nescafe in die Tasse. Wasser in die Tasse Einzelschritte verfeinern. Kessel mit Wasser füllen. Auf die Herdplatte stellen. Herdplatte anstellen. Warten bis Wasser kocht. Herdplatte abstellen. Glas öffnen. Menge Kaffeepulver auf den Löffel laden. Löffel in die Tasse leeren. Kessel von der Herdplatte nehmen. Tasse mit Wasser füllen Weiter verfeinern Entwurfsprinzip: Einsatz von Algorithmenmustern as (generische) Lösungsverfahren wird an einem möglichst einfachen Vertreter der Problemklasse vorgeführt und dokumentiert er Entwerfer versteht die Problemlösungsstrategie und überträgt diese auf sein Programm Konzept moderner Softwareentwicklung: "esign Patterns" Eine Bibliothek von Mustern ("esign Patterns", "best-practice"-strategien) wird genutzt, um einen abstrakten Programmrahmen zu generieren ie freien Stellen dieses Programmrahmens werden dann problemspezifisch ausgefüllt In modernen Programmiersprachen wird dies z.tl. schon weitergehend unterstützt durch parametrisierte Algorithmen und in objektorientierter Programmierung Vererbung mit Überschreiben

4 Algorithmenmuster Greedy greedy = gierig Prinzip gieriger Algorithmen: Versuche in jedem Teilschritt so viel wie möglich zu erreichen Beispiel Wechselgeld (bis Euro) herausgeben, mit minimaler Anzahl von Münzen à,,,,, und -Cent Greedy-Strategie: Nimm jeweils die größte Münze unter Zielwert, und ziehe diese von Zielwert ab Bsp: 8 Cent -> , d.h. Münzen Greedy berechnet bei diesem Problem immer die optimale Lösung wäre anders wenn nur Münzen à,, und Cent zu Verfügung stünden z.b. Cent zu wechseln Greedy: = +, d.h. Münzen optimal aber: =, d.h. Münzen Greedy: Optimales Kommunikationsnetz 8 Aufgabe: möglichst billige Vernetzung von vorgegeben Stationen eines Kommunikationsnetzes herstellen Jeder Knotenpunkt soll mit jedem anderen verbunden sein, ggf. auch auf Umweg über andere Knotenpunkte Bekannt sind Kosten für direkte Verbindungen Gesucht ist Teilmenge aller direkten Verbindungen, so dass alle Knoten untereinander verbunden sind die Gesamtkosten minimal sind (Optimierungsproblem!)

5 Greedy: Optimales Kommunikationsnetz 8. Schritt: Markiere beliebigen Knoten im Beispiel. Schritt: Betrachte alle Kanten von markierten zu unmarkierten Knoten - (Kosten ), - (Kosten ), - (Kosten ), - (Kosten ) und markiere Kante (und Zielknoten) mit geringsten Kosten Kante -, Knoten Greedy: Optimales Kommunikationsnetz 8. Schritt: Betrachte alle Kanten von markierten zu unmarkierten Knoten - (Kosten ), - (Kosten ), - (Kosten ) - (Kosten ), - (Kosten 8), - (Kosten ) und markiere Kante (und Zielknoten) mit geringsten Kosten Kante -, Knoten

6 Greedy: Optimales Kommunikationsnetz 8. Schritt: Betrachte alle Kanten von markierten zu unmarkierten Knoten - (Kosten ), - (Kosten ) - (Kosten ), - (Kosten ) - (Kosten 8), - (Kosten ) und markiere Kante (und Zielknoten) mit geringsten Kosten Kante -, Knoten Greedy: Optimales Kommunikationsnetz 8. Schritt: Betrachte alle Kanten von markierten zu unmarkierten Knoten - (Kosten ), - (Kosten ), - (Kosten 8), - (Kosten ) und markiere Kante (und Zielknoten) mit geringsten Kosten Kante -, Knoten Bem: markierte Knoten bilden jetzt einen "minimalen aufspannenden Baum" (minimal spanning tree) des Graphen

7 Greedy: Optimales Kommunikationsnetz Erste Variante des Algorithmus [ Teilbaum R besteht anfangs aus einem beliebigem Knoten ] while [ R noch nicht aufgespannt ]: [ suche billigste von R ausgehende Kante ] [ füge diese zu R hinzu ] 8 Verfeinerungen while-schleife durch for-schleife ersetzen da klar, dass Schleife genau (n-)-mal durchlaufen wird: anfangs Knoten in Baum, in jedem urchgang kommt ein Knoten hinzu Suche der billigsten Kante z.b. geschachtelte Schleife: für alle Knoten a für alle Knoten b teste ob Kante (a,b) von R ausgeht und billiger ist bisher betrachtete Kanten Greedy: Optimales Kommunikationsnetz Verfeinerte Variante des Algorithmus [ R = beliebiger Knoten von P ] for i = (n-): # suche billigste von R ausgehende Kante minkosten = MAXKOSTEN for j = (n-): for k = (j+) (n-): if Kante (j,k) geht von R aus and Kosten(j,k) < minkosten: minkosten = Kosten(j,k) billigstekante = (j,k) [ füge billigstekante zu R hinzu ] 8 Weitere Verfeinerungen atenstruktur zur arstellung von Baum festlegen am besten wäre es, eine eigene Klasse zu definieren (objektorientierte Prog.) als Behelf auch z.b. getrennte Speicherung von: treenodes: Liste der Knoten des Baums treeedges: Liste der Kanten des Baums

8 Greedy: Optimales Kommunikationsnetz Python-Code def minimalspanningtree(): treenodes = [] # initially only node in tree treeedges = [] #... and no edges def fromtreetooutside(a,b): if a in treenodes and b not in treenodes: return True if b in treenodes and a not in treenodes: return True return False for i in range(,size): # find cheapest edge leaving the current tree cheapestcost = MAXCOST for j in range(size): for k in range(j+,size): 8 if fromtreetooutside(j,k) and getcost(j,k) < cheapestcost: cheapestcost = getcost(j,k) cheapestedge = (j,k) # expand the current tree treeedges.append( cheapestedge ) a,b = cheapestedge hier nicht definiert: if a in treenodes: treenodes.append(b) getcost(j,k) Kosten für Kante (j,k) else: treenodes.append(a) SIZE Anzahl Knoten return treeedges MAXCOST - z.b. Lokale Funktion: Nur von äußerer Funktion aufrufbar. Hat Zugriff auf lokale Variablen der äußeren Funktion. atenstruktur für Graphen: Adjazenzmatrix (Nachbarschaftsmatrix) Graph mit n Knoten wird durch n n Matrix m repräsentiert ungerichtete Graphen ohne Kantengewichte: Kante (i,j) durch Eintag in m[i][j] und m[j][i] repräsentiert ungerichtete Graphen mit Kantengewichten: m[i][j] und m[j][i] enthalten Gewicht der Kante (i,j) bei ungerichteten Graphen ist Adjazenzmatrix symmetrisch bei gerichteten Graphen i.a. unsymmetrisch

9 arstellung von Matrizen in Python Matrix darstellbar als Liste von Listen: jede enthaltene Liste entspricht einer Zeile der Matrix >>> m = [ [,], [,] ] >>> print m[], m[] [, ] [, ] >>> print m[][], m[][], m[][], m[][] Potentielle Fehlerquelle beim Erzeugen von Matrizen: Enthaltene Listen müssen verschiedene (d.h. evtl. gleiche, aber nicht dieselben) Objekte sein Falls alle Teillisten dasselbe Objekt: Veränderungen an einer Teilliste wirken sich auf alle anderen aus! nicht gewollt bei Matrizen! >>> l = [,] >>> m = [l,l] >>> print m [[, ], [, ]] >>> l[] = >>> print l [, ] >>> print m [[, ], [, ]] Exkurs: Listen in Python Erzeugung von Listen Explizites Aufzählen (in eckigen Klammern) Zahlenfolgen mit range() >>> l = [,,] >>> l = range() >>> l [,,,, ] "Multiplikation" von Listen mit Zahl List comprehension Generierung von Liste aus Elementen einer andern Liste ähnlich ef. math. Mengen, z.b. : { i i =..} auch mit Test: nur Elemente, die Bedingung genügen, werden in neue Liste aufgenommen >>> l = [] * >>> l [,,,, ] >>> l = [ i** for i in range() ] >>> l [,,,, ] >>> l = [ i for i in range() if i% == ] >>> l [,,,, 8,,, ]

10 Exkurs: Listen in Python Slice-Operator l[min:max] Teilliste der Elemente von Index min (einschließlich) bis max (ausschließlich) l[min:] Teilliste ab Index min (einschließlich) l[:max] Teilliste bis Index max (ausschließlich) l[:] flache Kopie der Liste (Listenelemente werden nicht mit kopiert) >>> l = [,,,] >>> l[:] [,, ] >>> l[:] [,, ] >>> l[:] [, ] >>> l[:] [,,,] Exkurs: Listen in Python Flache und tiefe Kopien Alias anderer Name für gleiche Liste l = l Flache Kopie Liste wird kopiert, Elemente aber nicht l = l[:] Tiefe Kopie auch Listenelemente werden kopiert Modul copy l = deepcopy(l) Unterschiedl. Verhalten bei Hinzufügen oder Entfernen von Elementen der Original-Liste Ändern von Elementen der Originalliste >>> l = [ [,], [,] ] >>> l = l # Alias für l >>> l = l[:] # flache Kopie >>> from copy import deepcopy >>> l = deepcopy(l) >>> l.append([,]) >>> l [[, ], [, ], [, ]] >>> l [[, ], [, ]] >>> l [[, ], [, ]] >>> l[][] = >>> l [[, ], [, ], [, ]] >>> l [[, ], [, ]] >>> l [[, ], [, ]]

11 Erzeugen von n n Matrizen in Python Falsch: >>> def makematrixbuggy(n): return [ []*n ] * n >>> m = makematrixbuggy() >>> m [[, ], [, ]] >>> m[] [, ] >>> m[][] >>> m[][] = >>> m [[, ], [, ]] erzeugt Liste, deren n Elemente jeweils dieselbe Liste sind Richtig: >>> def makematrix(n): return [ []*n for i in range(n) ] >>> m = makematrix() >>> m [[, ], [, ]] >>> m[] [, ] >>> m[][] >>> m[][] = >>> m [[, ], [, ]] erzeugt Liste, deren n Elemente zwar gleich, aber nicht dieselbe Liste sind Kopieren so erzeugter Matrizen i.d.r. mit deepcopy()! Greedy: Optimales Kommunikationsnetz Analyse [ R = beliebiger Knoten von P ] for i = (n-): # suche billigste von R ausgehende Kante minkosten = MAXKOSTEN for j = (n-): for k = (j+) (n-): if Kante (j,k) geht von R aus and Kosten(j,k) < mincosts: minkosten = Kosten(j,k) billigstekante = (j,k) [ füge billigstekante zu R hinzu ] Laufzeit: proportional zu n Begründung: drei geschachtelte for-schleifen, die jeweils ungefähr n-mal durchlaufen werden Verbesserung möglich, so dass Laufzeit proportional zu n Algorithmus von Prim Algorithmus findet immer (global) optimale Lösung i.a. finden greedy-algorithmen nur lokales Optimum bei betrachtetem Problem gilt aber: lokales Optimum = globales Optimum

12 Wo Greedy fehlschlägt: Kürzeste Rundreise Gesucht: Rundreise durch alle Knoten, so dass jeder Knoten genau einmal besucht wird Rundreise am selben Knoten beginnt und endet Kosten minimal sind 8 Greedy-Strategie: beginne bei beliebigem Knoten gehe vom aktuellen Knoten zu dem unbesuchten Nachbarknoten mit geringsten Pfadkosten wiederhole, bis alle Knoten besucht gehe zurück zum Ausgangsknoten liefert im Beispiel z.b. Rundreise: (Kosten ) kürzere Rundreise z.b.: (Kosten ) optimale Lösung kann z.b. mit Backtracking gefunden werden Algorithmenmuster Backtracking Backtracking ist wichtiges Algorithmenmuster für Such- und Optimierungsprobleme Typische Anwendungsgebiete: Planungsprobleme (Routen- u. Tourenplanung), Konfigurierungen (z.b. VLSI-Layout), Optimierungen, Spielprogramme (Schach, ame, ), Backtracking realisiert eine allgemeine, systematische Suchtechnik Lösungsraum kann vollständig betrachtet werden Vorgehen nach Versuch-und-Irrtum-Prinzip (trial-and-error) versucht, schrittweise eine Teillösung zu Lösung auszubauen dabei systematisches Ausprobieren alternativer Lösungswege durch "Backtracking" zu früheren Entscheidungspunkten Beispiel: Maus und Käse Backtracking wird i.d.r. durch Rekursion implementiert

13 Backtracking: Finden in einem Labyrinth Jeder Weg (Konfiguration) kann mit einem Folgeschritt zu einem verlängerten Weg (Folgekonfiguration) erweitert werden Für jeden Weg (Konfiguration) ist entscheidbar, ob er eine Lösung ("Käse gefunden") oder keine Lösung ("Sackgasse" oder "Käse nicht gefunden") ist In der Sackgasse sucht die Maus keinen Folgeweg, sondern kehrt um zur vorherigen Konfiguration (Backtracking) zurück und sucht dort weiter as wiederholte Absuchen desselben Folgeweges muss verhindert werden Prinzip des Backtracking Prolemlösungsverfahren betrachtet zunächst Start-Konfiguration Für jede Konfiguration (Zustand) können i.a. mehrere Nachfolge-Konfigurationen (Zustände) erzeugt werden i.a. wird jede dieser Nachfolgekonfigurationen überprüft Für jede Konfiguration (Zustand) ist entscheidbar, ob es sich um eine Lösung handelt Backtracking-Muster: procedure backtrack(k: Konfiguration): if [K ist Lösung]: gib K aus else: for each [ direkte Erweiterung K' von K ]: backtrack( K' ) Aufruf von backtrack() mit Start-Konfiguration Backtracking terminiert garantiert, wenn nur endlich viele Konfigurationen bestehen jede Konfiguration höchstens einmal gestestet wird

14 Backtracking: Kürzeste Rundreise, bzw. Travelling salesman problem (tsp) Backtracking-Muster: procedure backtrack(k: Konfiguration): if [K ist Lösung]: gib K aus else: for each [ direkte Erweiterung K' von K ]: backtrack( K' ) 8 Traveling Salesman Problem: finde kürzeste Rundreise durch n Städte (jede Stadt darf nur einmal besucht werden, außer Start- = Zielort) Anpassung des Musters für Traveling Salesman Problem: procedure tsp( trip ): if [trip besucht alle Städte]: [erweitere trip um Heimreise zum Ausgangsort] [gib trip und Kosten dafür aus] else: for each [bislang unbesuchte Stadt s]: [ trip' = trip erweitert um Reise nach s] tsp( trip' ) Backtracking: Travelling salesman problem (tsp) Umsetzung in Python def tsp(trip): # solution found if len(trip) == SIZE: roundtrip = trip + [ trip[] ] # go home print "Roundtrip", roundtrip, "costs", getpathcost(roundtrip) # expand trip, try all unvisited cities else: for i in range(size): if i not in trip: tsp( trip + [i]) return # Hauptprogramm if name == ' main ': tsp([]) # start trip in city

15 Backtracking: Travelling salesman, Testlauf u. Analyse Roundtrip [,,,,, ] costs Roundtrip [,,,,, ] costs Roundtrip [,,,,, ] costs 8 Roundtrip [,,,,, ] costs 8 Roundtrip [,,,,, ] costs Roundtrip [,,,,, ] costs Es werden Rundreisen Roundtrip [,,,,, ] costs gefunden Roundtrip [,,,,, ] costs minimale Kosten (per Roundtrip [,,,,, ] costs Inspektion der Ergebnisse): Roundtrip [,,,,, ] costs jede Rundreise entspricht Roundtrip [,,,,, ] costs einer Permutation der Zahlen Roundtrip [,,,,, ] costs.. Roundtrip [,,,,, ] costs Für n Objekte gibt es n! Roundtrip [,,,,, ] costs Permutationen Roundtrip [,,,,, ] costs Roundtrip [,,,,, ] costs =! Roundtrip [,,,,, ] costs Laufzeit des Algorithmus Roundtrip [,,,,, ] costs proportional zu (n-)! Roundtrip [,,,,, ] costs damit nur für kleine n effektiv Roundtrip [,,,,, ] costs ausführbar Roundtrip [,,,,, ] costs (mit Code-Optimierungen z.b. Roundtrip [,,,,, ] costs 8 n = ) Roundtrip [,,,,, ] costs Roundtrip Prof. B. Jung [,,,,, Einführung ] costs in die Informatik, WS /8 TU Bergakademie Freiberg Backtracking: as Achtdamen-Problem as amenproblem (8 Queens Problem): Man finde eine Stellung für acht amen auf einem Schachbrett, so dass keine zwei amen sich gegenseitig schlagen können In Informatik auch auf n-amenproblem erweitert (Platzierung von n amen auf n n Brett) Zwei Lösungen des Achtdamen-Problems

16 Backtracking: as Achtdamen-Problem Vorgangsweise von oben nach unten, je ame in Zeile setzen (gleiche Zeile ausgeschlossen) dabei werden jeweils alle unbedrohten Felder der Zeile ausprobiert Lösung gefunden, wenn 8. ame auf unbedrohtem Feld platziert wird def PLATZIERE(i): # platziere ame in i-ter Zeile for h =.. 8: # alle Spalten h ausprobieren if [Feld in Zeile i, Spalte h nicht bedroht]: [setze ame auf dieses Feld (i,h)] if [Brett voll]: # d.h. i == 8 [Gib Konfiguration aus] else: PLATZIERE(i+) Konfigurations- bzw. Suchraum für -amenproblem [symmetrisch zu Teilbaum links] def PLATZIERE(i): # platziere ame in i-ter Zeile for h =.. 8: # alle Spalten h ausprobieren if [Feld in Zeile i, Spalte h nicht bedroht]: [setze ame auf dieses Feld (i,h)] if [Brett voll]: # d.h. i == 8 Lösung! [Gib Konfiguration aus] else: PLATZIERE(i+)

17 Backtracking: as Achtdamen-Problem Gegenseitige Bedrohung von amen, falls: gleiche Zeile (ausgeschlossen durch Algorithmus) gleiche Spalte gleiche iagonale def bedroht( (x,y), (x,y) ): if x == x: return True if y == y: return True if x+y == x+y: return True if x-y == x-y: return True return False # gleiche Spalte # gleiche Reihe # gleiche iagonale (aufwaerts) # gleiche iagonale (abwaerts) def istbedroht( (x,y), andere): # ist Feld bedroht? for xi,yi in andere: if bedroht( (xi,yi), (x,y) ): return True return False def platzierenaechsteame( bisher ): zeile = len(bisher) + for spalte in range(,): if not istbedroht( (zeile,spalte), bisher): jetzt = bisher + [ (zeile,spalte) ] if len(jetzt)==8: print "Loesung", jetzt else: platzierenaechsteame(jetzt) # Hauptprogramm if name == " main ": platzierenaechsteame([])

18 Backtracking: as Achtdamen-Problem Anzahl der Lösungen steigt mit der Brettgröße sehr stark an! Backtracking: Sudoku 8

19 Zusammenfassung Betrachtete Algorithmenmuster greedy berechnet lokales Optimum polynomiale Zeitkomplexität backtracking berechnet globales Optimum Zeitkomplexität entsprechend Größe des (problemspezifischen) Konfigurationsraums, z.b. exponentiell (proportional n ) oder auch noch schlimmer proportional zu n! vollständiges urchsuchen des Konfigurationsraums per Backtracking daher nur für kleinere Probleminstanzen praktisch durchführbar bei großen Probleminstanzen muss man sich evtl. mit lokalen Optima begnügen, z.b. per Greedy-Algorithmus berechnet Weitere Algorithmenmuster divide-and-conquer (vgl. Kapitel : Suche) dynamisches Programmieren (Literatur)