Informatik II (D-ITET) Übungsstunde 11, 17.05.2017 Hossein Shafagh, shafagh@inf.ethz.ch Distributed Systems Group, ETH Zürich
Ablauf Besprechung von Übung 10 Hinweise für Übung 11 (Sortieren, O-Notation)
L10.A1a Mergesort manuell 21 15 9 63 45 44 8 88 98 67 45 6 62 21 15 63 9 45 44 88 8 98 67 45 6 62 63 21 15 9 88 45 44 8 98 67 45 6 62 88 63 45 44 21 15 9 8 98 67 62 45 6 98 88 67 63 62 45 45 44 21 15 9 8 6 3
L10.A1b Mergesort pseudocode: sort() ArrayList sort (ArrayList unsorted, int begin, int end ) if ( end - begin == 0 ) return new ArrayList ( 0 ) if ( end - begin == 1 ) ArrayList result = new ArrayList ( 1 ) result.add ( unsorted[begin] ) return result // divide.. ArrayList lhs = sort ( unsorted, begin, (begin+end) / 2 ) ArrayList rhs = sort ( unsorted, (begin+end) / 2, end ) //..et impera return merge ( lhs, rhs ) 4
L10.A1b Mergesort pseudocode: merge() ArrayList merge (ArrayList lhs, ArrayList rhs ) int left = 0, right = 0 ArrayList result = new ArrayList ( lhs.size + rhs.size ) loop if ( left == lhs.size ) result.addall ( rhs.sublist ( right, rhs.size ) ) break if ( right == rhs.size ) result.addall ( lhs.sublist ( left, lhs.size ) ) break result.add ( lhs[left]>rhs[right]? lhs[left++] : rhs[right++] ) return result 5
L10.A1c,d Mergesort n*log(n) Messung f(n) 1000000 100000 10000 1000 100 10 1 0.1 0.01 0.001 800 1600 3200 6400 12800 25600 51200 n 6
L10.A1c,d Mergesort 7
Nicht benutzt wird: L10.A2 - Türme von Hanoi 3 2 1 Zusammenfassung: Anzahl der Scheiben (n): 4 Anzahl der Schritte (2^n-1): 15 Nicht benutzt werden: 3 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3 8
Wie sieht s mit 5 Türme aus? 1. 1 à 3 2 2. 1 à 2 3 3. 3 à 2 1 4. 1 à 3 2 5. 2 à 1 3 6. 2 à 3 1 9
7. 8. 9. 10. 1 à 3 2 1 à 2 3 3 à 2 1 3 à 1 2 11. 2 à 1 3 12. 3 à 2 1 10
13. 14. 15. 16. 1 à 3 2 1 à 2 3 3 à 2 1 3 à 1 2 17. 2 à 1 3 18. 2 à 3 1 11
19. 1 à 3 2 20. 2 à 1 3 21. 22. 3 à 2 1 3 à 1 2 23. 2 à 1 3 24. 2 à 3 1 12
25. 1 à 3 2 26. 1 à 2 3 27. 3 à 2 1 28. 3 à 1 2 29. 2 à 1 3 30. 2 à 3 1 13
31. 1 à 3 2 Zusammenfassung: Anzahl der Scheiben (n): 5 Anzahl der Schritte (2^n-1): 31 Nicht benutzt werden: 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 14
L10.A2 Türme von Hanoi (n Scheiben) Zusammenfassung: 5 Scheiben (31 Schritte): 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 1 2 4 Scheiben (15 Schritte): 3 2 1 3 2 1 3 2 1 3 2 1 3 2 1 3 Scheiben (7 Schritte): 2 3 1 2 3 1 2 15
L10.A2b Pseudocode moves = 2^n-1; counter = 0; if n even then while (counter < moves) make possible move between tower 1 and tower 2 make possible move between tower 1 and tower 3 make possible move between tower 2 and tower 3 increment counter by 3 units else [n is odd] while (counter < moves-1) make possible move between tower 1 and tower 3 make possible move between tower 1 and tower 2 make possible move between tower 3 and tower 2 increment counter by 3 units make available move between tower 1 and tower 3 make possible move à es gibt immer nur eine Möglichkeit (die kleinere Scheibe, oder die einzige Scheibe) 16
L10.A3 Reversi (Teil 4) Realisieren Sie eine Bewertungsfunktion, die nach dem α-β-verfahren arbeitet, ansonsten jedoch das gleiche leistet wie die reine Minmax-Methode der letzten Übungsserie. Am Einfachsten: 2 Funktionen: min und max, die sich abwechselnd aufrufen. Die eine ändert die Beta-Schranke, die andere die Alpha-Schranke 17
L10.A3 Reversi (Teil 4) BestMove max (int maxdepth, long timeout, GameBoard gb, int depth, int alpha, int beta) throws Timeout if (System.currentTimeMillis() > timeout) throw new Timeout(); if (depth==maxdepth) return new BestMove(eval(gb),null,true); ArrayList<Coordinates> availablemoves = new ArrayList<Coordinates>(gb.getSize()* gb.getsize()); for (int x = 1; x <= gb.getsize(); x++) for (int y = 1; y <= gb.getsize(); y++) { Coordinates coord = new Coordinates(x, y); if (gb.checkmove(mycolor, coord)) availablemoves.add(coord); } if (availablemoves.isempty()) if (gb.ismoveavailable(othercolor)) { BestMove result = min(maxdepth, timeout, gb, depth+1, alpha, beta); return new BestMove(result.value, null); } else return new BestMove(finalResult(gb), null); [...] 18
L10.A3 Reversi (Teil 4) BestMove max (int maxdepth, long timeout, GameBoard gb, int depth, int alpha, int beta) throws Timeout [...] Coordinates bestcoord = null; for (Coordinates coord : availablemoves) { GameBoard hypothetical = gb.clone(); hypothetical.checkmove(mycolor, coord); hypothetical.makemove(mycolor, coord); BestMove result = min(maxdepth, timeout, hypothetical, depth+1, alpha, beta); } if (result.value > alpha) { alpha = result.value; bestcoord = coord; } if (alpha >= beta) { return new BestMove(alpha, null); } return new BestMove(alpha, bestcoord); 19
Reversi-Turnier am Mittwoch, den 31.05.2017 um 12:30 Uhr, Stuz2 (CABinett) Eingabe: am Mittwoch, den 24.05.2017 bis 23:59 (Zürich Time) über die Reversi-Platform Allein oder Zweiergruppen (Alle Teammitglieder müssen jedoch dieses Semester die Vorlesung "Informatik II für ITET" belegt haben) 20
Ablauf Besprechung von Übung 10 Hinweise für Übung 11 (Sortieren, O-Notation)
U11 Aufwand von Algorithmen Problemumfang n Oft: Anzahl der Eingabewerte Komplexität eines Problems Geringstmöglicher Aufwand, der mit irgendeinem Lösungsalgorithmus erreicht werden kann Aufwand Oft ist der Aufwand eines Algorithmus nicht nur von der Problemgrösse n, sondern von den konkreten Eingabewerten bzw. deren Reihenfolge abhängig. Dann unterscheidet man i.a. folgende Fälle: Günstigster Aufwand ( best case ) Mittlerer Aufwand ( average case ) Ungünstigster Aufwand ( worst case ) 22
U11 Aufwand von Algorithmen Quelle: wikipedia.org 23
U11 Bubble sort Quelle: wikipedia.org 24
U11 Bubble sort Quelle: wikipedia.org 25
Complexity Classes θ (1) Constant Complexity θ (log n) Logarithmic Complexity θ (n ) θ (n log n) θ (n b ) θ (b n ) θ (n!) Linear Complexity n log n Complexity Polynomial Complexity Exponential Complexity Factorial Complexity 26
U11.A1 Complixity http://bigocheatsheet.com/ 27
U11.A2 Komplexitätsanalyse Analysieren Sie die Code-Fragmente in Bezug auf deren Laufzeit und geben Sie das Ergebnis in O-Notation an Gültige Abgabe Berechnungschritte und resultierende O-Notation! 28
U11.A2 Komplexitätsanalyse // Fragment 1 for (int i=0; i<n; i++) a++; // Fragment 2 for (int i=0; i<2n; i++) a++; for (int j=0; j<n; j++) a++; // Fragment 4 for (int i=0; i<n; i++) for (int j=0; j<i; j++) a++; // Fragment 5 while(n >=1 ) n = n/2; // Fragment 3 for (int i=0; i<n; i++) for (int j=0; j<n; j++) a++; // Fragment 6 for (int i=0; i<n; i++) for (int j=0; j<n*n; j++) for (int k=0; k<j; k++) a++; 29
U11.A2 Beispiel (Fragment 1) // Fragment 1 for (int i=0; i<n; i++) a++; c 0 c 1 *n + = c 0 + c 1 n 30
U11.A3 Komplexität (I) Zeit pro Operation Grösse der Eingabe Totale Laufzeit 31
U11.A3 Komplexität (II) 32
U11.A4 Ein Springer auf dem Schachbrett 33
U11.A4a Erreichbare Felder n Finde Menge von Feldern: n Erreichbar mit n Zügen n Gegeben: startposition 34
U11.A4a Ein Springer auf dem Schachbrett Klasse Position p = new Position(0,0); Position next = p.add(new Position(offX, offy)); Implementiert compareto, equals, etc. Methode getreachableset ArrayList<Position> getreachableset(position p, int n) p: Startposition n: Anzahl Hops returns: Knoten in der Menge 35
U11.A4b Backtracking Finde einen Weg Der über alle Felder geht & jedes Feld nur einmal besucht Spezialfall des Hamiltonian Path Problem Frühzeitiger Abbruch falls erreichbare Felder alle besucht Backtracking: löschen der letzten Züge bis Abbruchbedingung nicht mehr erfüllt 36
Das war s! Geniesst den Sommer und viel Erfolg bei der Prüfung!