Informatik II Übung 09
Informatik II Übung 09
Informatik II Übung 09
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
<strong>Informatik</strong> <strong>II</strong><br />
<strong>Übung</strong> <strong>09</strong><br />
Christian Beckel<br />
beckel@inf.ethz.ch<br />
02.05.2013<br />
Lösung U8.A1a,b – Binäre Suche<br />
0<br />
3<br />
1<br />
7<br />
2 3 4 5 6 7 8 9 10 11 12 13 14<br />
17 25 33 47 56 62 65 66 68 70 78 89 92<br />
li mi re<br />
mi = (re-li)/2 + li;<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
2
Lösung U8.A1c – Binäre Suche (mit Faktor 3)<br />
0<br />
3<br />
1<br />
7<br />
2 3 4 5 6 7 8 9 10 11 12 13 14<br />
17 25 33 47 56 62 65 66 68 70 78 89 92<br />
li mi re<br />
mi = (re-li)/3 + li;<br />
Fazit: wenn ich nach kleinen Zahlen suche ist diese Methode schneller, im<br />
Durchschnitt aber schlechter (tiefer Baum)<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
3<br />
Lösung U8.A1d – BinarySearch<br />
! Sub-arrays immer zu kopieren ist keine gute Idee<br />
" lieber eine eigene Methode erstellen, die zusätzlich zwei int-Werte, begin und<br />
end als Parameter nimmt:<br />
public Value find(ArrayList haystack, Key needle)<br />
{<br />
return findRecursive(haystack, needle, 0, haystack.size());<br />
}<br />
private Value findRecursive( ArrayList haystack,<br />
Key needle, int begin, int end)<br />
{<br />
}<br />
...<br />
Eclipse DEMO<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 4
Lösung U8.A2 – Tic-Tac-Toe<br />
MAX<br />
Strategie von<br />
MAX<br />
MIN<br />
MAX<br />
MIN<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
5<br />
Lösung U8.A3a – checkMove: how to<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 6
Lösung U8.A3a – checkMove<br />
! boolean checkMove(GameBoard …,Coordinates c)<br />
! Feld muss frei sein!<br />
! Überprüfen alle Richtungen<br />
! Solange nicht mindestens eine Richtung „gültig“ ist…<br />
for( int i = -1; i
Lösung U8.A3b – GreedyPlayer<br />
! Player-AI<br />
! für alle möglichen Züge<br />
! Simuliere Zug auf Kopie des aktuellen Boards<br />
! Bewerte die resultierende Situation<br />
! Speichere Zug und Bewertung in einer Liste<br />
! Sortiere die Liste / Such das/die Maximum/Maxima<br />
! Wähle den/zufällig einen maximalen Zug<br />
! Bewertungsfunktion (bisher)<br />
! Verhältnis eigene Steine vs. Gegnersteine<br />
! Datenstrukturen<br />
! MoveInfo: speichert ausgewertete Zuginformationen<br />
! Coordinates und Bewertung<br />
! List (z.B. eine ArrayList)<br />
! effizienter als ein Vector<br />
! praktischer als ein Array<br />
Ähnliche Lösung<br />
ohne Liste:<br />
Eclipse DEMO<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 9<br />
HINWEISE ZU U9<br />
A1 – Rucksackproblem (Backtracking)<br />
A2 – Spielbaumauswertung<br />
A3 – Reversi (Teil 3)<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
10
U9.A1 – Rucksackproblem und Backtracking<br />
x2<br />
g2, w2<br />
x3<br />
g3, w3<br />
x1<br />
g1, w1<br />
x4<br />
g4, w4<br />
x5<br />
g5, w5<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 11<br />
Hinweise zu U9.A1<br />
x1<br />
g1, w1<br />
x2<br />
g2, w2<br />
x3<br />
g3, w3<br />
Das allgemeine Rucksackproblem<br />
! k Gegenstände x 1 , ..., x k ; Jeweils bekannter Wert und Gewicht<br />
! Auswahl von Gegenständen, sodass Gesamtgewicht nicht überschritten<br />
wird<br />
! Optimierungsproblem: Maximieren des Wertes der ausgewählten<br />
Gegenstände<br />
x4<br />
g4, w4<br />
x5<br />
g5, w5<br />
a) Theorie<br />
b) Bruteforce Ansatz<br />
c) Backtracking Ansatz<br />
d) Vergleich von Bruteforce und Backtracking<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
12
U9.A1 – Teilmengen<br />
! Wie viele unterschiedlichen Möglichkeiten hat unser Dieb?<br />
! M = Menge der „verfügbaren“ Gegenständen<br />
! Der Dieb kann nur eine Teilmenge davon nach Hause bringen<br />
! Der Dieb kann auch die leere Menge Ø (fauler Dieb) oder die gesamte<br />
Menge M (starker Dieb mit grossem Sack) schaffen!<br />
! #Teilmengen := #Elemente in der Potenzmenge von M<br />
! Beispiel<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 13<br />
U9.A1 – Backtracking<br />
! Was heisst „Backtracking“?<br />
! Prinzip: “trial and error”<br />
! Beispiel: Ausgang in einem Labyrinth suchen<br />
! Sich für eine Richtung entscheiden<br />
! In diese Richtung weitergehen<br />
! Wenn “letztendlich” erfolglos<br />
! zurückkehren und eine andere Richtung wählen<br />
! Wenn “letztendlich” erfolgreich<br />
! fertig…<br />
Backtracking<br />
Falls bereits alle Richtungen<br />
ausprobiert<br />
" noch weiter zurück.<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 14
<strong>Informatik</strong> <strong>II</strong><br />
15<br />
<strong>Informatik</strong> <strong>II</strong><br />
16
Warum?<br />
Warum?
U9.A1 – Einfache Diebstrategie<br />
! Einfachen Algorithmus implementieren<br />
! zur Erinnerung:<br />
! Eine Menge M mit |M|=k besitzt 2^k Teilmengen<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 19<br />
U9.A1 – Einfache Diebstrategie<br />
! Zu implementierendes Verfahren in Pseudocode:<br />
1. Initialisierung<br />
2. Nimm nächste Konfiguration (wie genau…?)<br />
3. Berechne das gesamte Gewicht<br />
if (gesamtes Gewicht < G)<br />
berechne Gesamtwert<br />
if (neuer Gesamtwert > Gesamtwert aktuelle optimale Lösung)<br />
aktuelle Konfiguration ist neue optimale Lösung<br />
4. Falls noch Konfigurationen übrig,<br />
gehe zu Punkt 2<br />
else<br />
Berechnung fertig<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 20
U9.A1.a – Einfache Diebstrategie<br />
! Liefert die einfache Dieb-Strategie immer das optimale Ergebnis?<br />
! Ja/Nein<br />
! Warum? ....<br />
! Gibt es immer genau eine optimale Lösung?<br />
! Ja/Nein?<br />
! Warum? ...<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 21<br />
U9.A1b,c – Bitwertigkeit<br />
! Konfiguration als Bitfolge: class Selection<br />
! Die Bitwertigkeit bezeichnet den Stellenwert eines einzelnen Bits, den es durch<br />
seine Position innerhalb einer Binärzahl hat.<br />
MSB - Most Significant Bit/Byte<br />
‣ Das höchstwertige Bit ist das Bit, das innerhalb der Zahl<br />
an der Stelle mit dem höchsten Stellenwert steht.<br />
LSB - Least Significant Bit/Byte<br />
‣ Analog dem MSB besitzt das niedrigstwertige Bit den<br />
niedrigsten Stellenwert.<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 22
U9.A1b,c – Tipps für die Implementation<br />
! class Selection ist gut Dokumentiert<br />
! Achtung: bei Vergrösserung der Konfiguration (neuen Gegenstand in den Sack<br />
legen, A1c) muss der neue Stellenwert initialisiert werden<br />
! Beispiel-Selections für die Menge M<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 23<br />
U9.A1b,c – Tipps für die Implementation<br />
Bruteforce Ansatz:<br />
public Selection findBest(ArrayList values,<br />
ArrayList weights,<br />
int maxWeight)<br />
{<br />
...<br />
}<br />
int last = java.Math.pow(2, values.size()); //Anzahl der Teilmengen<br />
for( int i = 0; i < last; i++ )<br />
{<br />
new Selection(values.size(), i); //Selection Bitfeld mit Wert i<br />
...<br />
}<br />
...<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 24
U9.A1b,c – Tipps für die Implementation<br />
! Backtracking Ansatz:<br />
! FindResult Klasse (Selection und Value zusammen)<br />
! Rekursive Methode:<br />
FindResult fr = find(currSelection, currWeight, values, weights, maxWeight);<br />
! Abbruchbedingung: selection.size()==values.size(); //alles berücksichtigt<br />
! In der Methode zwei mögliche Richtungen zum Weitergehen:<br />
//Gegenstand hinterlassen<br />
Selection without = new Selection(...); //um eins vergrössern, bit auf 0 setzen<br />
//und weiter nach unten im Baum<br />
//prüfen ob Gewicht passt, dann Gegenstand mitnehmen<br />
...<br />
Selection with = new Selection(...); //um eins vergrössern, bit auf 1 setzen<br />
//und weiter nach unten im Baum<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 25<br />
Hinweise zu U9.A2<br />
Spieltheorie/Spielbaumauswertung<br />
a) Bisschen Theorie<br />
b) Minimax-Algorithmus<br />
c) Optimale Strategie für MAX-Spieler<br />
d) Alpha/Beta-Algorithmus<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
26
U9.A2 – Spieltheorie<br />
! Bestanteile eines Spielbaums<br />
! Wurzel " Aktuellen Spielstellung<br />
! Knoten " Spielzustand<br />
! Kante " Spielzug<br />
! Blatt " Endzustand, (Spiel zu Ende)<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 27<br />
U9.A2b – Minimax-Algorithmus<br />
! Algorithmus zur Ermittlung der optimalen Spielstrategie für<br />
Nullsummenspiele<br />
! Sichert höchstmöglichen Gewinn bei optimaler Spielweise des<br />
Gegners<br />
! Bei Nicht-Nullsummenspielen können andere Algorithmen besser sein<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 28
U9.A2b – Minimax-Algorithmus<br />
?<br />
0<br />
0 +1<br />
0<br />
0 +1 0 -1 +1 -1<br />
-1 +1 0 0<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 29<br />
U9.A2c – Strategie für Max<br />
! Strategie<br />
! Eine Strategie (für Max) sei ein Graph, der aus dem Spielbaum<br />
entsteht, indem man alle Kanten streicht und nur für jeden Max-<br />
Knoten eine einzige ausgehende Kante übrig lässt<br />
Also i.A. eine Menge von<br />
Knoten/Kanten, nicht nur ein<br />
Pfad!!<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 30
U9.A2d – Der α-β-Algorithmus<br />
Online Beispiel durchgerechnet:<br />
http://www.vs.inf.ethz.ch/edu/FS2012/I2/slides/Info2-ITET-AlphaBeta.pdf<br />
(user: i2 password: i22012)<br />
Online JAVA Applet:<br />
http://www.ocf.berkeley.edu/~yosenl/extras/alphabeta/alphabeta.html<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
31
Alpha-Beta-Algorithmus<br />
! <strong>Übung</strong>sbeispiel online, wir schauen mal rein...<br />
12.05.2011<br />
<strong>Informatik</strong> <strong>II</strong><br />
35<br />
Alpha-Beta-Algorithmus
Alpha-Beta-Algorithmus<br />
beta<br />
Beta-Schnitt: MAX wird sicher einen Wert grössergleich 20 erreichen. Eine<br />
10 ist bereits bekannt. Der Wert des Teilbaums spielt keine Rolle!<br />
Alpha-Beta-Algorithmus<br />
alpha<br />
beta<br />
Alpha-Schnitt: MIN wird sicher einen Wert kleinergleich 8 erreichen. Eine 10<br />
ist bereits bekannt. Der Wert des Teilbaums spielt keine Rolle!
Hinweise zu U9.A3 – Reversi (Teil 3)<br />
HumanPlayer<br />
RandomPlayer<br />
GreedyPlayer<br />
MinMaxPlayer<br />
nextMove()<br />
nextMove()<br />
nextMove()<br />
wartet auf Eingabe<br />
von der<br />
Kommandozeile<br />
nextMove()<br />
wählt ein<br />
zufälligen<br />
(aber gültigen!)<br />
nächsten Zug<br />
wählt nächsten<br />
Zug<br />
anhand einer<br />
einfachen,<br />
nicht-rekursiven<br />
Bewertungsfunktion<br />
wählt nächsten<br />
Zug<br />
anhand Min-Max-<br />
Analyse mit<br />
neuer<br />
Bewertungsfunktion<br />
Download<br />
<strong>Übung</strong> 7 <strong>Übung</strong> 8 <strong>Übung</strong> 9<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
39<br />
U9.A3a – Reversi (Teil 3)<br />
! Auswertung von Spielbäumen<br />
! Implementieren Sie eine Methode, die den Spielbaum mit MinMax (oder<br />
NegaMax) maximal bis zur Tiefe d auswertet (abwechselnd Max und Min)<br />
! Suchtiefe konfigurierbar<br />
! Rekursiver Ansatz<br />
! Spielbaum rekursiv aufbauen<br />
! Situation auf Tiefe d bewerten<br />
! Minmax auf erhaltene Wertung ergibt die Strategie<br />
! Alle Spezialfälle berücksichtigen (z.B. passen)!<br />
! Noch keine Zeitbegrenzung<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 40
U9.A3b – timeLimit<br />
! Zeitbegrenzung pro Zug:<br />
! Vor Ablauf von timeLimit Millisekunden soll ihre Methode nextMove() einen<br />
gültigen Zug zurückgeben<br />
! Seht einen kleinen Zeitbuffer vor (Grössenordnung einige 10ms), das<br />
Abbrechen und Resultat-zurückliefern passiert nicht sofort!<br />
! Möglicher Ansatz: eine out-of-time-exception werfen<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 41<br />
U9.A3c – Bewertungsfunktion (I)<br />
! Als „Inspirationsquelle“ könnt Ihr u.A. folgenden Artikel benutzen:<br />
! „The Development of a World Class Othello Program“, Kai-Fu Lee and<br />
Sanjoy Mahajan, 1990<br />
! Zum Herunterladen von der Reversi-Webseite<br />
! username: i2bib<br />
! password: reversi<br />
! Artificial Intelligence: A Modern Approach<br />
! Stuart Russell and Peter Norvig (2nd Edition, 2003)<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 42
U9.A3c – Bewertungsfunktion (<strong>II</strong>)<br />
! Mögliche „Bewertungsfunktionen“<br />
! Wie viele Steine werden umgedreht?<br />
! Wo liegen die umgedrehte Steine (innen/Rand)?<br />
! ....<br />
! Hinsichtlich dem Turnier empfiehlt sich<br />
! die Idee für die Bewertungsfunktion erst einmal mittels Pseudocode<br />
festzuhalten<br />
! den Pseudocode weiter zu entwickeln<br />
! der Pseudocode gibt erste Hinweise darauf, was für Informationen für jeden<br />
Zug berechnet werden müssen<br />
! aus den verschiedenen Versionen des Pseudocodes nach und nach den<br />
Turnierspieler implementieren<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9 43<br />
…viel Spass!<br />
<strong>Informatik</strong> <strong>II</strong> - <strong>Übung</strong> 9<br />
44