Praktische Informatik I – Der Imperative Kern Randomisierte Algorithmen

(1)

Praktische Informatik I – Der Imperative Kern Randomisierte Algorithmen

Prof. Dr. Stefan Edelkamp

Institut für Künstliche Intelligenz

Technologie-Zentrum für Informatik und Informationstechnik (TZI) Am Fallturm 1, 28359 Bremen

+49-(0)421-218-64007 www.tzi.de/~edelkamp

(2)

Outline

1 Der Zufall spielt mit

2 Randomisierter Primzahltest

3 Mister X

4 Mastermind

5 Handlungsreisen mit Zeitfenstern

6 Rechteckpacken

Stefan Edelkamp (IAI) PI 1 – Imperativer Kern January 9, 2014 2 / 36

(3)

Übersicht

In diesem Abschnitt lernen Sie randomisierte Algorithmen und die randomisierte Monte-Carlo Suche kennen, die auf

Zufallsentscheidungen (vgl. Münzwurf) bauen.

Randomisierte Algorithmenspielen eine wichtige Rolle in der Informatik.

Dabei beruhen die Berechnungen üblicherweise auf den Pseudo-ZufallszahlenGenerator vonLehmer

Der sogenannteMersenne-Twisterliefert eine etwas bessere Verteilung.

Oft können algorithmische Probleme besonderselegant und effizient durch einen randomisierten Algorithmus gelöst werden.

(4)

Randomisierte Algorithmen

Randomisierte Algorithmensindnicht-deterministisch.

Ihr Verhalten hängt vom Ausgang von Zufallsexperimenten ab.

Diese Idee wurde erstmals von Miller und Rabin durch einen randomisierten Primzahltestbekannt.

Inzwischen gibt es für eineVielzahl von Problemenrandomisierte Algorithmen, die (in dem einen oder anderen Sinne)schnellersind als deterministische Verfahren.

Außerdem sind randomisierte Algorithmen häufigeinfacher zu verstehen und zu implementierenals deterministische Algorithmen.

(5)

Literatur und Einteilung

Empfehlenswerte Bücher sind u.a.

R. Motwani und P. RaghavanRandomized Algorithms

M. Mitzenmacher und E. UpfalProbability and Computing(beide Cambridge University Press), oder

J. HromkovicRandomisierte Algorithmen(Teubner).

Man unterteilt die Verfahren dabei gerne in

Monte-CarloMethoden, die häufig korrekt sind – engl. mostly correct– und

Las-VegasMethoden, die immer korrekt sind aber eine vom Zufall abhängige Laufzeit haben.

Beispiele: randomisierter Primzahltest (MC), randomisiertes Quicksort (LV)

(6)

Outline

3 Mister X

4 Mastermind

6 Rechteckpacken

(7)

Rabins Primzahltest

Ein Paradebeispiel für einen randomisierten Algorithmus ist der Primzahltest von (Miller, Selfridge und) Rabinin Programm 1.

Das Verfahren wurde unabhängig vonSolovoy und Strassengefunden worden, es wurde allerdings mehrfach im Gutachterprozessabgeleht Der Test kann durchaus fehlerhafte Ergebnisse liefern, jedoch mit verschwindend kleiner Wahrscheinlichkeit

Lange Zeit war nicht bekannt, ob es einenpolynomiellenAlgorithmus gibt, der das Primzahlproblemdeterministischentscheidet.

(8)

Programm 1:Die randomisierte Bestimmung von Primzahlen.

importjava.util.Random;

public classPrime {

booleanwitness(inta,intn) { intd= 1;

intk=log(n)+1;

for(inti=k−1;i>=0;i−−) { d= (d∗d) %n;

if((((n−1) >>i) & 1) == 1) d= (d∗a) %n;

}

return(d== 1);

}

public booleantest(intn) { Random r=newRandom();

for(inti= 0;i<100;i++) { inta= 1 +r.nextInt(n−1);

if(!witness(a,n))return false;

}

System.out.println("probably prime");

return true;

} }

(9)

Sieb des Eratostenes

Primzahlen können im Prinzip mit demSieb des Eratostenesaus der Menge der natürlichen Zahlen ausgefiltert werden.

Dabei werden nach und nach eineListe von Primzahlengeneriert.

Für einepotentielle Primzahlx wird mit steigenden 2≤n≤ b√ xc geprüft, obnden Wertx teilt.

Überlegung: Wenn es zwei Teiler einer Zahlx gibt, so ist ein Teiler kleiner als die Wurzel vonx.

Programm 2 realisiert diese Idee (wir haben√

x auf 100 festgelegt).

Leider ist der Algorithmus für größere Zahlenx nicht effizient

(10)

Programm 2:Die Bestimmung von Primzahlen nach Erastosthenes.

public classEratosthenes {

public voidisPrime(intx) { inti,j=0;

intn=3;

intprimes[] =new int[100];

primes[0] = 2;

booleanprime=true;

if(x%2==0 &&x!=2) {prime=false;n= 2; } while(n<=Math.sqrt(x)) {

i= 0;

booleanprime2=true;

while(primes[i]∗primes[i]<=n) {

if(n%primes[i]==0) {prime2=false;break; } i++;

}

if(prime2) {

if(x%n==0) {prime=false;break; } if(j<100)primes[j++] =n;

} n+=2;

}

if(prime)System.out.println(x+" is a prime number!");

elseSystem.out.println(x+" = "+n+"∗"+(x/n));

}

} Stefan Edelkamp (IAI) PI 1 – Imperativer Kern January 9, 2014 10 / 36

(11)

Bedeutung und Polynomialität

Der Test, ob eine natürliche Zahl eine Primzahl ist, ist ein grundlegendes Problemder Mathematik und Informatik.

Darüber hinaus gehört er zu den wichtigen algorithmischen Aufgaben mit großerpraktischerBedeutung.

Das bekannteste Public-Key Kryptosystem – dasRSA-System– verwendet große zufällige Primzahlen, um die Kryptanalyse zu erschweren.

Hierfür generiert man einezufällige ungerade Zahlaus einem vorgegebenen Bereich und führt den Primzahltest durch.

M. Dietzfelbinger berichtet in seinem BuchPrimality Testing in Polynomial Timeüber diesen Test sowie eines der zentralen

theoretischen Ergebnisse der letzten Zeit, dass der Primzahltest auch ohne Randomisierung inPolynomialzeitfunktioniert.

(12)

Outline

3 Mister X

4 Mastermind

6 Rechteckpacken

(13)

Nicht bei Scottland Yard

Eine alternative Verwendung für den Zufall ist das eines

Gegenspielers, wie im SpielMister X: Eine ausgewählte Zahl soll in möglichst wenig Versuchenerraten werden.

Programm 3 bietet einenautomatischen Löseran, der in einer best-möglichenAnzahl von Vergleichen die zufällig ausgewählte Lösung bestimmt.

Die Lösung benötigt auch für einebeliebige/ungünstigeWahl der Zufallszahl einekleine Anzahlvon Vergleichen

Da sich die Intervallgröße jeweils halbiert, ist die Anzahl der Vergleiche somitlogarithmischin der Intervallgröße.

Dieses mächtige Prinzip derbinären Suchetaucht in vielen Bereichen der Informatik auf.

(14)

Programm 3:Das Spiel Mister X.

public classMisterX {

private intx,left,right,trials;

publicMisterX(intd) { trials=left= 0;right=d;

Random r=newRandom();

x=r.nextInt(d);

}

public voidsolve() { while(true) {

trials++;

inty= (left+right)/2;

System.out.println("Mister X−my "+trials+". guess is "+y);

if(x<y) {System.out.println("...too big");right=y; } if(x>y) {System.out.println("...too small");left=y; }

if(x==y) {System.out.println("...correct, "+trials+" trials");break; } }

}

public voidguess(inty) { trials++;

System.out.println("Mister X−your "+trials+". guess is "+y);

if(x<y)System.out.println("...too big");

if(x>y)System.out.println("...too small");

if(x==y)System.out.println("...correct, "+trials+" trials");

}

(15)

Outline

3 Mister X

4 Mastermind

6 Rechteckpacken

(16)

Wer ist der/das Mastermind?

ImMastermind-Spiel wird ein nummerischer Code automatisch ausgewählt und muss erraten werden.

Dabei werdenStatistikenüber die richtige Wahl einer Zahl und die richtige Positionierung geführt.

Donald E. Knuthhat 1976 gezeigt, dass ein Code mit 4 Stellen und 6 Zahlen inmaximal fünf Zügenzu knacken ist

Das Programm 5 verwirklicht das Spiel, wobei der Computer sich die Zufallszahl imKonstuktorselbst wählt.

Auf die einzelnen Stellen wird mittelsDivision mit Restzugegriffen, so dass nur eineeinzige Zahleingegeben werden muss.

Der Einfachheit halber sind allenZahlenpaarweise unterschiedlich⇒ Das Programm ist auf 9 Zahlen beschränkt.

(17)

Programm 4:Ein MasterMind Spiel.

public classMasterMind {

private int[]secret;

private int[]input;

intsize,trials;

publicMasterMind(intn) { size=n;

trials= 0;

Random r=newRandom();

secret=new int[size];

input=new int[size];

for(inti=0;i<size;i++) { booleanduplicate=false;

do{

duplicate=false;

secret[i] = 1+r.nextInt(9);

for(intj=0;j<i;j++)

if(secret[i] ==secret[j])duplicate=true;

}while(duplicate);

}

System.out.println("Mastermind has chosen "+size+" distinct numbers between 1 and 9");

}

(18)

Programm 5:Ein MasterMind Spiel.

public voidguess(inty) { trials++;

System.out.println("your "+trials+". number is "+y);

booleanhurray=true;

for(inti=0;i<size;i++) { input[size−i−1] =y% 10;

y=y/ 10;

}

for(inti=0;i<size;i++) { booleanred=false;

booleanblack=false;

for(intj=0;j<size;j++)

if(input[i] ==secret[j])red=true;

if(input[i] ==secret[i]) {

System.out.println((i+1) +". position, MM code "+secret[i]+" = your code "+input[i ]);

black=true;

} else{

if(red)System.out.println((i+1) +". position, MM _ ~ your code "+input[i]);

elseSystem.out.println((i+1) +". position, MM _ # your code "+input[i]);

}

hurray=hurray&black;

}

if(hurray)System.out.println("hurray, you broke the code");

}

(19)

Outline

3 Mister X

4 Mastermind

6 Rechteckpacken

(20)

Das TSPTW Problem

Werden weitere Bedingungen (engl. Constraints) an das Problem des Handlungsreisenden gestellt, wie

die Einhaltung vonKapazitätsrestriktionenoder die Einhaltung vonZeitfenstern

so wird das Problem, dieoptimale Lösungzu berechnen, schon für kleiner Werte vonnzur einer Herausforderung.

BeiZeitfensterngeht man davon aus, dass die zurückgelegteStrecken inder dafür vergangenenZeitgemessen werden undAufträgein den entsprechenden Städtennur zu bestimmten Zeitenerledigt werden können.

Wir nutzenrandomisierte Suchansatz aus Programm 6, der aus der Auswertung zufälliger Touren – engl. rollout– über die Zeitlernt

(21)

Was gelernt wird . . .

Es wird dabei die Güte, von einer Städt zur Nächsten zu reisen, gelernt: diePolitk

Performanz:

(22)

Politikadaption

DieWahrscheinlichkeitender Nachfolgerauswahl, die durch ein Rouletteraddurchgeführt wird, verändern sich über die Zeit.

Für das eingegebene Problem werden die paarweise

Nähebeziehungen von Städtenin einer Matrix nach und nach erschlossen.

Man spricht hier vonPolitik-Adaption(engl. policy adaptation).

Die Angleichung der Werte geschieht dadurch, dass die Nachfolger in einer Verbesserten Lösung eineErhöhung ihrer Politik-Werte(+ 1.0) erfahren, während die anderen eineErniedrigung ihrer Politik-Wertein Kauf nehmen müssen.

Diese Erniedrigung geschieht auf Basis derBolzmann-Gleichungund beinhaltet den Aufruf derExponentialfunktion.

(23)

Nested Monte-Carlo Search

Diegeschachtelte Sucheist einKompromisszwischen der Suche nach neuen Lösungen (engl. exploration) und der Bestärkung bestehender Lösungen (engl. exploitation).

Anzahl der Rollouts: i^d, wobeid die Suchtiefe undi die Anzahl der Iterationen ist

Die randomisierte Suche ist aus dem Einpersonenspiel abgeleitet, so dass die Nachfolgerauswahl gern’ auch alsZugbezeichnet wird.

Die rekursive und für das Problem effektive Such-Prozedur nutzt nur an einer Stelledomänenspezifisches Wissen

Damit ist der Nested-Monte Carlo Ansatz nahezuuniverselleinsetzbar.

(24)

Programm 6:Die Lösung des TSPTWs.

Tour search(intlevel) { Tour best=newTour();

best.score=MAXVALUE;

if(level== 0) { rollout();

best.score=evaluate();

for(intj= 0;j<N+1;j++)best.tour[j] =tour[j];

}else{

for(intk= 0;k<N;k++)for(intn= 0;n<N;n++)local[level][k][n] =policy[k][n];

for(inti= 0;i<ITERATIONS;i++) { Tour r=search(level−1);

doublescore=r.score;

if(score<best.score) { best.score=score;

for(intj= 0;j<N+1;j++)best.tour[j] =r.tour[j];

if(level> 2)

System.out.println("Level : "+level+", score : "+score);

adapt(best.tour,level);

} }

for(intk= 0;k<N;k++)for(intn= 0;n<N;n++)policy[k][n] =local[level][k][n];

}

returnbest;

}

(25)

Programm 7: TSP mit Zeitfenstern: Evaluation.

public doubleevaluate() { doublemakespan= 0.0;

doublecost= 0.0;

intprev= 0;// starts at the depot intviolations= 0;

for(inti= 1;i<N;i++) { intnode=tour[i];

cost+=dist[prev][node];

makespan=Math.max(makespan+dist[prev][node],left[node]);

if(makespan>right[node])violations++;

prev=node;

}

cost+=dist[prev][0];

makespan=Math.max(makespan+dist[prev][0],left[0]);

if(makespan>right[0])violations++;

return100000.0∗violations+cost;

}

(26)

Programm 8:TSP mit Zeitfenstern: Rollout.

public voidrollout() { intnode= 0;

tourSize= 1;

for(inti=1;i<N;i++)visited[i] =false;

while(tourSize<N) {

intsuccessors=legalMoves();

for(inti= 0;i<successors;i++)

value[i] =Math.exp(policy[node][moves[i]]);

doublesum=value[0];

for(inti= 1;i<successors;i++) sum+=value[i];

doublemrand=random.nextDouble()∗sum;

inti= 0;

sum=value[0];

while(sum<mrand) { i++;

sum+=value[i];

}

tour[tourSize++] =moves[i];

visited[moves[i]] =true;

node=moves[i];

}

tour[tourSize++] = 0;// Finish at the depot;

(27)

Programm 9:TSP mit Zeitfenstern: Politikadaption.

voidadapt(int[]tour_param,intlevel) { for(intk= 1;k<N;k++)

visited[k] =false;

intsuccessors;

intnode= 0;

for(intply= 0;ply<N;ply++) { successors= 0;

for(inti= 1;i<N;i++) { if(!visited[i]) {

moves[successors] =i;

successors++;

} }

local[level][node][tour[ply]] += 1.0;

doublez= 0.0;

for(inti= 0;i<successors;i++) z+=Math.exp(policy[node][moves[i]]);

for(inti= 0;i<successors;i++)

local[level][node][moves[i]]−=Math.exp(policy[node][moves[i]]) /z;

node=tour[ply];

visited[node] =true;

} } }

(28)

Programm 10:TSP mit Zeitfenstern: Legale Züge.

public intlegalMoves() { intprev= 0;// starts at the depot intopindex= 0;

doublemakespan= 0.0;

doublecost= 0.0;

for(inti= 1;i<tourSize;i++) {// computes makespan intnode=tour[i];

cost+=dist[prev][node];

makespan=Math.max(makespan+dist[prev][node],left[node]);

prev=node;

}

if(tourSize> 0)

prev=tour[tourSize−1];

for(inti= 1;i<N;i++) { if(!visited[i]) {

moves[opindex] =i;

booleantooLate=false;

for(intj= 1;j<N;j++) if(j!=i&& !visited[j])

if((makespan<=right[j]) && (makespan+dist[prev][j] <=right[j])

&& (Math.max(makespan+dist[prev][i],left[i]) >right[j])) { tooLate=true;

break;

} if(!tooLate)

opindex++;

} }

if(opindex== 0) for(inti= 1;i<N;i++)

if(!visited[i]) moves[opindex++] =i;

returnopindex;

}

(29)

Outline

3 Mister X

4 Mastermind

6 Rechteckpacken

(30)

Alle Quadrate in ein Rechteck

Spezialfall: Alle Quadrate 1x1,. . .,NxN in ein umgebendes Quadrat L×B.

Lösungen(FormN :L×B) 2: 2 x 3, 3: 3 x 5, 4: 5 x 7, 5: 5 x 12, 6: 9 x 11, 7: 7 x 22, 7: 11 x 14, 8: 14 x 15, 9: 15 x 20, 10: 15 x 27, 11: 19 x 27, 12: 23 x 29, 13: 22 x 38, 14: 23 x 45, 15: 23 x 55, 16: 27 x 56, 16:

28 x 54, 17: 39 x 46, 18: 31 x 69, 19: 47 x 53, 20: 34 x 85, 21: 38 x 85, 22: 39 x 98, 23: 64 x 68, 24: 56 x 88 und 25: 43 x 129

(31)

Programm 11:Quadrat-im-Rechteck: Rollout-Funktion.

introllout() {

intcost= 0,objectsSize= 0,violations= 0;intnextreme= 1;extreme[0] = 0;

for(intj=0;j<N;j++)visited[j] =false;

while(objectsSize<N) {

intsuccessors=legalMoves(nextreme);

doublesum= 0;

for(inti=0;i<successors;i++) {

value[i] =Math.exp(policy[code(loc[i],moves[i])]);

sum+=value[i]; }

doublemrand=random.nextDouble()∗sum;

inti=0;sum=value[0];

while(sum<mrand)sum+=value[++i];

intobject=moves[i];

packing[objectsSize] =loc[i];

objects[objectsSize++] =object;

intx=loc[i]/YSIZE,y=loc[i]%YSIZE;

place(object,x,y);

visited[object] =true;

nextreme=update(object,x,y,nextreme);

if(cost<x+sizes[object].x)cost=x+sizes[object].x;

if(x+sizes[object].x>OPT)violations+= ((x+sizes[object].x)−OPT);

}

clear(cost);

return// 100000∗(violations) + 100∗cost+violations+nextreme;

(32)

Programm 12: Quadrat-im-Rechteck: Adaptierungs-Funktion.

voidadapt(int[]objects_param,int[]packing_param,intcost,intlevel) { for(intj=0;j<N;j++)

visited[j] =false;

intobject= 0;

intnextreme= 1;

extreme[0] = 0;

for(intp=0;p<N;p++) {

intsuccessors=legalMoves(nextreme);

object=objects_param[p];

local[level][code(packing_param[p],object)] +=ALPHA;

doublez= 0.0;

for(inti=0;i<successors;i++)

z+=Math.exp(policy[code(packing_param[p],moves[i])]);

for(inti=0;i<successors;i++)

local[level][code(packing_param[p],moves[i])]−=ALPHA∗

Math.exp(policy[code(packing_param[p],moves[i])])/z;

intx=packing_param[p]/YSIZE,y=packing_param[p]%YSIZE;

place(object,x,y);

nextreme=update(object,x,y,nextreme);

visited[object] =true;

}

clear(cost);

(33)

Programm 13: Quadrat-im-Rechteck: Hilfs-Funktionen.

booleanintersect(intobject,intx,inty) { if(y+sizes[object].y>YSIZE)return true;

intj= 0;

while((j<sizes[object].y) &&

(grid[x][y+j] ==−1 &&grid[x+sizes[object].x−1][y+j] ==−1))j++;

if(j<sizes[object].y)return true;

j= 0;

while((j<sizes[object].x) &&

(grid[x+j][y] ==−1 &&grid[x+j][y+sizes[object].y−1] ==−1))j++;

return(j<sizes[object].x);

}

voidclear(intcost) { for(inti= 0;i<cost;i++)

for(intj= 0;j<YSIZE;j++) grid[i][j] =−1;

}

booleanemptyrow(intx,inty1,inty2) { for(inti=y1;i<y2;i++)

if(grid[x][i] !=−1)return false;

return true;

}

booleanemptycolumn(intx1,intx2,inty) { for(inti=x1;i<x2;i++)

if(grid[i][y] !=−1)return false;

return true;

(34)

Programm 14: Quadrat-im-Rechteck: Generierung der Kinder.

intlegalMoves(intnextreme) { intsuccessors= 0;

if(successors== 0) { for(inti= 0;i<N;i++) {

if(!visited[i]) {

for(intl= 0;l<nextreme;l++) { intx=extreme[l] /YSIZE;

inty=extreme[l] %YSIZE;

if(!intersect(i,x,y)) {

if(x> 0 &&grid[x−1][y] ==−1 &&grid[x−1][y+sizes[i].y−1] ==−1) while(x>0 &&emptyrow(x−1,y,y+sizes[i].y))x−−;

if(y> 0 &&grid[x][y−1] ==−1 &&grid[x+sizes[i].x−1][y−1] ==−1) while(y>0 &&emptycolumn(x,x+sizes[i].x,y−1))y−−;

if(x> 0 &&grid[x−1][y] ==−1 &&grid[x−1][y+sizes[i].y−1] ==−1) while(x>0 &&emptyrow(x−1,y,y+sizes[i].y))x−−;

if(y> 0 &&grid[x][y−1] ==−1 &&grid[x+sizes[i].x−1][y−1] ==−1) while(y>0 &&emptycolumn(x,x+sizes[i].x,y−1))y−−;

loc[successors] =x∗YSIZE+y;

moves[successors++] =i;

} } } } }

returnsuccessors;

(35)

Programm 15:Aktualisierung der Extrempunkte.

intupdate(intobject,intx,inty,intnextreme) { for(intl= 0;l<nextreme;l++) {

if(grid[extreme[l]/YSIZE][extreme[l]%YSIZE] !=−1) {

if(extreme[l]/YSIZE> 0 &&grid[extreme[l]/YSIZE][extreme[l]%YSIZE] ==object&&

grid[extreme[l]/YSIZE][extreme[l]%YSIZE] ==grid[extreme[l]/YSIZE−1][extreme[l]%YSIZE] &&

extreme[l]%YSIZE+sizes[object].y<YSIZE&&grid[extreme[l]/YSIZE][extreme[l]%YSIZE+sizes[object].y] ==−1) extreme[l] =extreme[l]+sizes[object].y;

else

if(extreme[l]%YSIZE> 0 &&grid[extreme[l]/YSIZE][extreme[l]%YSIZE] ==object&&

grid[extreme[l]/YSIZE][extreme[l]%YSIZE] ==grid[extreme[l]/YSIZE][extreme[l]%YSIZE−1]&&

extreme[l]/YSIZE+sizes[object].x<XSIZE&&

grid[extreme[l]/YSIZE+sizes[object].x][extreme[l]%YSIZE] ==−1) extreme[l] =extreme[l]+YSIZE∗sizes[object].x;

}

if(grid[extreme[l]/YSIZE][extreme[l]%YSIZE] !=−1) { for(intk=l;k<nextreme−1;k++)extreme[k] =extreme[k+1];

l−−;nextreme−−;

} }

intxnew=x+sizes[object].x,ynew=y,cextreme=nextreme;

if(xnew<XSIZE) {

while(ynew> 0 &&grid[xnew][ynew−1] ==−1)ynew−−;

if(grid[xnew][ynew] ==−1) {extreme[cextreme++] =xnew∗YSIZE+ynew;nextreme=cextreme; } } xnew=x;ynew=y+sizes[object].y;

if(ynew<YSIZE) {

while(xnew> 0 &&grid[xnew−1][ynew] ==−1)xnew−−;

if(grid[xnew][ynew] ==−1) {extreme[cextreme++] =xnew∗YSIZE+ynew;nextreme=cextreme; } } for(intl= 0;l<nextreme−1;l++)

if(extreme[l] ==extreme[l+1]) {

for(intk=l;k<nextreme−1;k++)extreme[k] =extreme[k+1];

nextreme−−;

}

(36)

Wrapping Up

Randomisierte Algorithmen zeigen durch die Zufallsentscheidung in jedem Lauf ein anderes Verhalten. Sie können den

schlechtesten Fall entschärfen oder die Lösung mit eine geringe Fehlerwahrscheinlichkeit schneller finden.

Die randomisierte Suche löst ein Problem durch Zufallswahl, indem von einem Zustand nach einer Wahrscheinlichkeitsverteilung Nachfolgerzustände besucht werden.

Diskussion (untereinander):

Welche Probleme kennen Sie, die Zufallsentscheidungen erfordern?

Was können Sie tun, um die Anzahl der Rollouts zu verringern?

Nennen Sie weitere Einpersonenspiele, die sich durch randomisierter Suche lösen lassen.