Sudokulösare: Jämförelse av körtiderför backtracking och mänskligastrategier

DEGREE PROJECT, IN COMPUTER SCIENCE , SECOND LEVEL STOCKHOLM, SWEDEN 2015

Sudokulösare: Jämförelse av körtider

för backtracking och mänskliga

strategier

SAMIUL A, MARK W

Sudokul¨

osare: J¨

amf¨

orelse av k¨

ortider f¨

or

backtracking och m¨

anskliga strategier

SAMIUL ALAM MARK WONG

Degree Project in Computer Science, DD143X Handledare: Jens Lagergren

Sammanfattning

Abstract

Inneh˚

all

1 Terminologi 5 2 Introduktion 6 3 Bakgrund 7 3.1 Tidigare forskning . . . 7 3.1.1 Backtracking . . . 7 3.1.2 Villkorsprogrammering . . . 7 3.1.3 M¨anskliga strategier . . . 8 3.2 Syfte . . . 8 3.3 Problemformulering . . . 9 3.3.1 Avgr¨ansningar . . . 9 4 Metod 10 4.1 Programmeringsspr˚ak . . . 10

4.2 Sudokul¨osare med backtracking . . . 10

4.3 Sudokul¨osare med m¨anskliga strategier och backtracking . . . 11

4.4 Testdata . . . 12

5 Resultat 13 5.1 Backtracking . . . 13

5.2 M¨anskliga strategier . . . 13

5.3 J¨amf¨orelse av k¨ortid . . . 14

6 Analys & Diskussion 16 6.1 Metodkritik . . . 17

1

Terminologi

Nyckelord som anv¨ands i uppsatsen:

rutn¨at - Spelplanen som best˚ar av 9x9 celler.

zon - En kvadratisk enhet som best˚ar av 3x3 celler. Zonerna ¨ar f¨ordelade s˚a att det finns tre zoner p˚a varje rad.

cell - En kvadratisk ruta som kan inneh˚alla inget eller en siffra mellan 1-9. ledtr˚ad - Antalet ifyllda celler i ett rutn¨at vid en given probleminstans. latinsk kvadrat - En matris d¨ar elementen ¨ar ordnade s˚a att varje rad och varje kolumn inneh˚aller element av olika typ.

2

Introduktion

Sudoku ¨ar ett pussel som g˚ar ut p˚a att fylla ett rutn¨at med siffror. Rutn¨atet f¨or ett standard Sudoku ¨ar 9x9 rutor stort och indelat i nio zoner p˚a 3x3 rutor var. Varje probleminstans best˚ar av ett rutn¨at med ett antal fr˚an b¨orjan k¨anda siffror s˚adant att det finns en unik l¨osning. Det ¨ar probleml¨osarens uppgift att fr˚an detta utg˚angsl¨age f¨ardigst¨alla probleminstansen genom att fylla i resten av cellerna. En giltig l¨osning har hittats d˚a varje rad, kolumn samt zon inneh˚aller siffrorna 1-9 endast en g˚ang. Detta ¨ar allts˚a precis som konstruktionen av en latinsk kvadrat.

3

Bakgrund

3.1

Tidigare forskning

Sudoku ¨ar ett v¨al unders¨okt ¨amne inom forskningsv¨arlden mycket p˚a grund av dess popularitet och matematiska egenskaper. McGuire et al. (2013) har visat att det finns 16 · 1027_{olika Sudoku. Vidare bevisade McGuire att det inte finns}

n˚agon giltig Sudoku som inneh˚aller f¨arre ¨an 17 ledtr˚adar. Kovacs (2012) har beskrivit olika typer av brute-force algoritmer och skillnaderna mellan dessa. Dessa algoritmer beh¨over i v¨arsta fall testa alla m¨ojliga l¨osningar tills en giltig l¨osning ¨ar funnen. Crook (2009) har unders¨okt en algoritm som ¨ar inspirerad av m¨anskliga strategier. Denna algoritm skiljer sig avsev¨art fr˚an brute-force algoritmen eftersom den ¨ar kapabel till att g¨ora smartare ins¨attningar genom att utesluta otill˚atna ins¨attningar. Ett exempel ¨ar en probleminstans d¨ar en zon endast saknar en siffra. Brute-force algoritmen testar i v¨arsta fall alla siffror fr˚an 1-9 medan denna algoritm utesluter de siffror som redan finns i zonen.

3.1.1 Backtracking

En av brute-force algoritmerna som Kovacs har beskrivit g˚ar systematiskt ige-nom alla tomma celler fr˚an v¨anster till h¨oger och uppifr˚an ned. I den f¨orsta tomma cellen s¨atter algoritmen in en etta. Om ins¨attningen inte strider mot spelreglerna g˚ar algoritmen vidare till n¨asta tomma cell och s¨atter in en etta. Om detta leder till en konflikt ¨okar vi siffran f¨or den senaste ins¨attningen. Vid fallet d˚a alla m¨ojliga siffror leder till en konflikt backar algoritmen till den senas-te fungerande ins¨attningen och ¨okar dess v¨arde med ett. Algoritmen forts¨atter tills en l¨osning ¨ar hittad. Denna algoritm kallas f¨or backtracking. Till skillnad fr˚an en totals¨okningsalgoritm utv¨arderar inte denna alla m¨ojliga, inklusive fel-aktiga, l¨osningsf¨orslag utan letar sig sakta men s¨akert till den korrekta. Algoritmens v¨arsta-falls-komplexitet ¨ar O(nm_{) d¨ar n ¨ar antal alternativ f¨or}

en cell och m ¨ar antalet tomma celler i probleminstansen. Mer specifikt blir tidskomplexiteten f¨or ett standard Sudokupussel i v¨arsta fallet O(9m_{). Detta}

eftersom varje tom cell inneb¨ar nio alternativ till l¨osningsf¨orslag. I och med att en given ledtr˚ad i en probleminstans inneb¨ar en tom cell mindre att fylla i v¨axer k¨ortiden f¨or denna algoritm exponentiellt n¨ar antalet ledtr˚adar minskar. 3.1.2 Villkorsprogrammering

3.1.3 M¨anskliga strategier

Davis (2012) har beskrivit strategier som m¨anniskor anv¨ander n¨ar de l¨oser Sudo-ku. Dessa strategier ¨ar grundade i m¨anniskans f¨orm˚aga att se m¨onster och ute-sluta alternativ. Vidare har Davis rangordnat dessa strategier efter hur sv˚ara de ¨

ar att applicera f¨or en m¨anniska. Nedan f¨oljer de f¨orsta fyra av Davis m¨anskliga strategier.

Unik fr˚anvarande kandidat:

I fallet d˚a en rad, kolumn eller zon inneh˚aller ˚atta siffror ˚aterst˚ar endast en m¨ojlig kandidat och placeras d¨armed i den enda tomma cellen.

Naken singel:

I fallet d˚a en specifik kandidat enbart kan placeras i en cell tillh¨orande en rad, kolumn eller zon placeras den i den cellen.

G¨omd singel:

En g¨omd singel uppst˚ar n¨ar en siffra endast finns som kandidat f¨or en cell i en rad, kolumn eller zon. Det som skiljer en g¨omd singel fr˚an en naken singel ¨ar att cellen med den g¨omda singeln kan inneha flera kandidater.

L˚ast kandidat:

Det kan h¨anda att det finns en zon i vilken en kandidat endast kan placeras i celler som faller inom en av de tre m¨ojliga raderna eller kolumnerna. I och med att kandidaten m˚aste finnas just i denna zon kan den uteslutas som kandidat fr˚an resten av raden eller kolumnen.

I v¨arsta fallet har en probleminstans fr˚an b¨orjan varken n˚agon unik fr˚anvarande singel, naken singel, g¨omd singel eller l˚ast kandidat. Om man d˚a v¨aljer att fr˚an detta stadie l¨osa probleminstansen med backtracking blir v¨arsta-falls-komplexiteten ¨

aven f¨or denna algoritm O(9m_).

3.2

Syfte

Uppsatsen unders¨oker skillnader mellan tv˚a olika typer av Sudokul¨osare. Mer specifikt j¨amf¨or uppsatsen f¨or¨andringar i k¨ortiden f¨or dessa Sudokul¨osare med avseende p˚a antalet ledtr˚adar i probleminstansen. Den f¨orsta algoritmen till¨ampar endast backtracking. Den andra algoritmen inleder med m¨anskliga strategi-er. N¨ar algoritmen inte kan g˚a vidare med m¨anskliga strategier anv¨ander den backtracking f¨or att komplettera probleminstansen.

skapar f¨oruts¨attningar f¨or att framtida probleml¨osare ska g¨ora strategiska val n¨ar de skapar sin egen Sudokul¨osare.

3.3

Problemformulering

Hur j¨amf¨or sig k¨ortiden f¨or backtracking algoritmen mot k¨ortiden f¨or backtrac-king med m¨anskliga strategier i Sudokuproblemet med avseende p˚a antalet led-tr˚adar?

3.3.1 Avgr¨ansningar

Vi kommer endast implementera tre av de beskrivna m¨anskliga strategierna. 1. Unik fr˚anvarande singel

2. Naken singel 3. G¨omd singel

4

Metod

4.1

Programmeringsspr˚

ak

Vi har valt att implementera algortimerna i Java som ¨ar ett objektoriente-rat h¨ogniv˚asspr˚ak. ¨Aven om Java inte presterar lika bra som ett kompilerat l˚agniv˚asspr˚ak som C eller C++ med avseende p˚a k¨ortid ger b˚ada spr˚aken sam-ma insikt eftersom det ¨ar f¨orh˚allandet mellan k¨ortiderna f¨or de olika algorit-merna vi vill unders¨oka. Vidare ¨ar Java plattformsoberoende vilket underl¨attar replikation av v˚ar unders¨okning.

Vidare ber¨aknas den genomsnittliga k¨ortiden f¨or respektive algoritm och resul-taten sammanst¨alls f¨or analys. F¨or att ber¨akna k¨ortid anv¨ands Javas inbyggda metod System.nanoTime(). Enligt Java-dokumentationen (2015) ger detta den mest precisa tidsm¨atningen.

4.2

Sudokul¨

osare med backtracking

1 SudokuSolver(Matrix m): 2 B¨orja i det ¨ovre v¨anstra h¨ornet.; 3 foreach tom cell c i M do 4 for i ← 1:9 do

5 if i ¨ar en till˚aten ins¨attning then 6 c ← i

7 if SudokuSolver(M) is true then 8 return true; 9 else 10 c ← 0; 11 end 12 end 13 end 14 return false; 15 end 16 return true;

Figur 2: Pseudokod f¨or backtracking algoritmen

Backtracking algoritmen f¨or Sudokuproblem har gjorts och publicerats ti-digare (Stanford, 2008). Eftersom teorin bakom backtracking ¨ar trivial kan vi med f¨ordel ˚ateranv¨anda en befintlig implementation och d¨armed undvika att ˚ateruppfinna hjulet. Se pseudokoden fr˚an Stanford i figur 2.

och med nio tills det g˚ar. I en probleminstans kan det finnas flera till˚atna ins¨attningar i en tom cell. Givet en giltig probleminstans kommer ett av dessa tal garanterat vara en korrekt ins¨attning.

I fallet d˚a ins¨attningen i en tom cell ¨ar till˚aten g˚ar algoritmen vidare och itererar samma process i n¨asta tomma cell. H¨ar ¨ar det inte garanterat att n˚agon av de nio siffrorna ¨ar korrekta eftersom den f¨oreg˚aende ins¨attningen kan vara till˚aten men inte korrekt. I det fallet backar algoritmen till den f¨oreg˚aende ins¨attningen och inkrementerar den. Algoritmen forts¨atter tills den har fyllt alla tomma cel-ler med den korrekta ins¨attningen.

Denna algoritm ¨ar den som anses vara den mest primitiva algoritmen efter totals¨okningsalgoritmen. Det ¨ar d¨arf¨or l¨ampligt att anv¨anda backtracking algo-ritmens k¨ortid och komplexitet som referensv¨arde vid utv¨ardering av m¨anskliga strategier.

4.3

Sudokul¨

osare med m¨

anskliga strategier och

backtrac-king

1 HumanWithBacktracking(Matrix m): 2 Skapa en kandidatlista f¨or varje tom cell;

3 while Det finns celler med endast en kandidat i kandidatlistan do 4 Ins¨attning av kandidat i cellen;

5 Borttagning av kandidat fr˚an kandidatlistorna i cellerna p˚a raden; 6 Borttagning av kandidat fr˚an kandidatlistorna i cellerna p˚a kolumnen; 7 Borttagning av kandidat fr˚an kandidatlistorna i cellerna p˚a zonen; 8 end

9 B¨orja i det ¨ovre v¨anstra h¨ornet; 10 foreach tom cell c i M do 11 for i in kandidatlista do

12 if i ¨ar en till˚aten ins¨attning then 13 c ← i

Algoritmen med m¨anskliga strategier implementerar tre av Davis (2012) strategier: unik fr˚anvarande singel, naken singel och g¨omd singel. Algoritmen skapar en kandidatlista f¨or varje tom cell i probleminstansen. Sedan s¨oker den efter de tomma celler vars kandidatlistor endast inneh˚aller en kandidat. Den kandidaten s¨atts in i cellen. Sedan tas detta v¨arde bort fr˚an kandidatlistorna f¨or de tomma cellerna i samma rad, kolumn och zon. Som konsekvens kan detta leda till att fler celler h¨arefter endast har en kandidat. Dessa fylls i p˚a samma s¨att. Denna process itereras tills inga fler celler har endast en kandidat. D¨arefter l¨oses resten av probleminstansen med backtracking.

Dessa strategier ¨ar de mest grundl¨aggande ur ett implementationsperspektiv. Att unders¨oka dessa ger en inblick i hur m¨anskliga strategier p˚averkar k¨ortiden.

4.4

Testdata

F¨or att besvara fr˚agest¨allningen k¨ors b˚ada algoritmerna med samma testfall. F¨or att ta h¨ansyn till anomalier bland probleminstanser beh¨ovs en stor m¨angd testdata f¨or respektive grupp av pussel. Eftersom det inte finns probleminstan-ser med f¨arre ¨an 17 ledtr˚adar inneh˚aller f¨orsta klassen probleminstanser med 17 ledtr˚adar. F¨or att se hur k¨ortiderna f¨or¨andras i takt med att antalet ledtr˚adar ¨

okar unders¨oks ¨aven k¨ortider f¨or probleminstanser med 18 till 21 ledtr˚adar. B˚ada algoritmerna kr¨aver en giltig probleminstans f¨or att returnera en unik l¨osning. Alla testfall genereras d¨arf¨or med hj¨alp av Ericsons (2015) Sudokuge-nerator som beskriver en probleminstans med hj¨alp av siffror. Symbolerna - och ! anv¨ands som avskiljare f¨or radslut och zonslut. Ericsons (2015) problemin-stanser konverteras sedan till 2D vektorer i Java enligt formatet i figur 4.

5

Resultat

5.1

Backtracking

Figur 5 visar den genomsnittliga k¨ortiden f¨or backtracking i nanosekunder f¨or en probleminstans i respektive probleminstansklass.

Ledtr˚adar K¨ortid (1 · 109_ns)

17 4.004 18 2.828 19 1.824 20 0.276 21 0.129

Figur 5: Genomsnittlig k¨ortid per probleminstans f¨or Sudokul¨osare med m¨anskliga strategier.

5.2

M¨

anskliga strategier

Figur 6 visar den genomsnittliga k¨ortiden f¨or m¨anskliga strategier i nanosekun-der f¨or en probleminstans i respektive probleminstansklass. Figur 7 visar det h¨ogsta antalet singlar i en probleminstans och det genomsnittliga antalet sing-lar per probleminstans f¨or varje klass. Figur 8 visar det genomsnittliga antalet kandidater som varje tom cell inneh¨oll efter initialiseringen av probeminstansens kanddiatlistor.

Ledtr˚adar K¨ortid (1 · 109ns) 17 3.444 18 2.420 19 0.930 20 0.158 21 0.088

Figur 6: Genomsnittlig k¨ortid per probleminstans f¨or Sudokul¨osare med backtrac-king.

Ledtr˚adar H¨ogsta antalet singlar Singlar per probleminstans

17 2 0.101

18 9 0.303

19 13 0.707

20 19 1.384

21 11 1.374

Ledtr˚adar Kandidater per ruta 17 4.796 18 4.624 19 4.467 20 4.301 21 4.140

Figur 8: Genomsnittligt antal kandidater per tom ruta efter m¨anskliga strategier.

5.3

J¨

amf¨

orelse av k¨

ortid

Figur 9 visar f¨orh˚allandet mellan de genomsnittliga k¨ortiderna f¨or backtracking och m¨anskliga strategier. De bl˚a staplarna visar k¨ortider f¨or backtracking. De gula staplarna visar k¨ortider f¨or m¨anskliga strategier. Figur 10 visar den procen-tuella minskningen av k¨ortid f¨or m¨anskliga strategier j¨amf¨ort med backtracking.

6

Analys & Diskussion

K¨ortiderna f¨or b˚ada algoritmerna minskar n¨ar antalet ledtr˚adar ¨okar. Detta be-ror p˚a att b˚ada algoritmerna har f¨arre tomma celler att behandla. I figur 9 och 10 ser vi att m¨anskliga strategier ger en f¨orb¨attrad k¨ortid f¨or varje proble-minstansklass. Detta inneb¨ar att v˚ar implementation av Davis (2012) f¨orsta tre m¨anskliga strategier har varit gynnsamma.

I figur 8 ser vi att det genomsnittliga antalet kandidater per ruta minskar n¨ar antalet ledtr˚adar ¨okar. Mer intressant ¨ar att antalet kandidater per ruta halveras n¨ar m¨anskliga strategier har eliminerat de alternativ som leder till konflikt. Antalet kandidater per ruta f¨or samtliga probleminstansklasser ligger inom intervallet (4,5). M¨anskliga strategier algoritmen g˚ar d¨arefter vidare med backtracking och har d˚a i snitt 4-5 kandidater att prova. Detta ger en genom-snittlig tidskomplexitet p˚a n¨ara O(4m) f¨or probleminstanser med 21 ledtr˚adar och en genomsnittlig tidskomplexitet p˚a n¨armare O(5m) n¨ar antalet ledtr˚adar g˚ar mot 17. Det ¨ar en av orsakerna till den f¨orb¨attring av k¨ortid som uppst˚ar n¨ar m¨anskliga strategier anv¨ands j¨amf¨ort med backtracking som alltid har en tidskomplexitet p˚a O(9m_).

Den markanta skillnaden mellan algoritmernas tidskomplexitet ¨overs¨atts dock inte direkt till exponentiellt b¨attre k¨ortid. Det tar tid f¨or algoritmen med m¨anskliga strategier att f¨orminska antalet tomma celler i indatat innan den p˚ab¨orjar backtracking. Se hur algoritmen itererar ¨over alla celler i probleminstansen och skapar en kandidatlista i kodavsnittet nedan. Den modifierade backtracking som algoritmen med m¨anskliga strategier anv¨ander ¨ar dessutom l˚angsammare ¨an en-bart backtracking. Detta beror p˚a att algoritmen itererar ¨over alla tomma celler i probleminstansen och s¨oker efter celler som endast har en kandidat. N¨ar den kandidaten fylls i itererar algoritmen ¨over alla tomma celler i samma rad, ko-lumn och zon som den ifyllda cellen och tar bort den ifyllda siffran ifall den finns i de andra cellenrnas kandidatlista. Se ¨aven detta i kodavsnittet nedan. Det ¨ar m˚anga operationer som backtracking algoritmen inte g¨or. D¨aremot beh¨over al-goritmen med m¨anskliga strategier endast iterera ¨over kandidater f¨or varje tom cell j¨amf¨ort med backtracking algoritmen som itererar ¨over alla tal fr˚an ett till nio. Som konsekvens blir k¨ortiden b¨attre med m¨anskliga strategier.

1 /**

2 * Creates a candidatelist for every empty cell in the grid. 3 * Then calls removeCandidates to remove conflicting

4 * candidates.

5 */

6 public void initCandidates(int[][] grid) { 7 for(int j = 0; j<9; j++) {

8 for(int i = 0; i<9; i++) { 9 if(grid[i][j] == 0) {

12 ... 13 } 14 15 /**

16 * Finds cells with only one candidate and fills them in. 17 * Consequently removes conflicting canidates in other cells.

18 */

19 public void findHiddenSingles(int[][] grid) { 20 for (int row = 0; row < grid.length; row++) { 21 for (int col = 0; col < grid.length; col++) { 22 if (grid[row][col] == 0) {

23 if(cMatrix[row][col].candidateList.size() == 1) { 24 int num = cMatrix[row][col].candidateList.get(0); 25 grid[row][col] = num;

26 removeInsertedCandidate(grid, row, col, num);

27 ...

28 }

I figur 9 och 10 ser vi att k¨ortidstrenden f¨or b˚ada algoritmerna g˚ar mot korta-re k¨ortider. St¨orst f¨orb¨attring mellan algoritmerna sker vid problemsinstanser med 19 ledtr˚adar. M¨anskliga algoritmer ger d¨ar en k¨ortid som ¨ar 49% b¨attre ¨an backtracking. Det kan bero p˚a att v˚ar testdata inneh˚aller olika j¨amn spridning av ledtr˚adar i de olika testklasserna eller inneh˚aller olika m˚anga probleminstan-ser som g˚ar att l¨osa snabbt. F¨or att f˚a svar p˚a varf¨or skillnaden ¨ar st¨orst vid probleminstanser med 19 ledtr˚adar rekommenderar vi en unders¨okning av hur spridningen av ledtr˚adar p˚averkar k¨ortiden f¨or b˚ada algoritmerna. Alternativt kan fler testfall anv¨andas f¨or att j¨amna ut skillnaden mellan enskilda proble-minstanser och d¨armed minska variansen.

6.1

Metodkritik

F¨or att potentiellt f¨orb¨attra k¨ortiden kan fler av Davis m¨anskliga strategier im-plementeras. Det ¨ar dock viktigt att v¨aga tidskostnaderna f¨or de nya strategierna mot resultatet. En ineffektiv implementation kan leda till h¨ogre tidskomplexitet och d¨armed f¨ors¨amrad k¨ortid. Metoden kan ocks˚a utvidgas till att unders¨oka probleminstansklasser med fler ledtr˚adar. Det ¨ar n¨odv¨andigt att unders¨oka om k¨ortidstrenden forts¨atter n¨ar antalet ledtr˚adar ¨okar eller om det finns en punkt d˚a tidsvinsten ¨ar f¨orsumbar. I det senare fallet vore det till exempel mer ekono-miskt med avseende p˚a minne att anv¨anda backtracking algoritmen.

7

Slutsats

Referenser

[1] JF Crook. A pencil-and-paper algorithm for solving sudoku puzzles. Notices of the AMS, 56(4):460–468, 2009.

[2] Tom Davis. The mathematics of sudoku, 2006. [3] Kjell Ericson. Generate and solve sudoku. 2015.

[4] Tim Kovacs. Artificial intelligence through search: Solving sudoku puzzles. 2008.

[5] Gary McGuire, Bastian Tugemann, and Gilles Civario. There is no 16-clue sudoku: Solving the sudoku minimum number of 16-clues problem. arXiv preprint arXiv:1201.0749, 2012.

[6] Helmut Simonis. Sudoku as a constraint problem. In CP Workshop on modeling and reformulating Constraint Satisfaction Problems, volume 12, pages 13–27. Citeseer, 2005.