Sudokulösare: Jämförelse av körtider för backtracking och mänskliga strategier

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 KTH ROYAL INSTITUTE OF TECHNOLOGY CSC SCHOOL

Sudokulösare: Jämförelse av körtider för backtracking och mänskliga strategier SAMIUL ALAM MARK WONG Degree Project in Computer Science, DD143X Handledare: Jens Lagergren Examinator: Örjan Ekeberg CSC, KTH, 2015-05 1

Sammanfattning Sudokulösare av alla typer är vida undersökta inom forskningsvärlden. Denna rapport undersöker skillnader i körtid och tidskomplexitet mellan backtracking strategin och mänskliga strategier för Sudokupussel indelade i klasser med 17-21 ledtrådar. Backtracking jämförs med vår egen implementation av mänskliga strategier med testdata som innehåller 99 Sudokupussel för varje klass. Studien visar att både körtid och tidskomplexitet är mindre för mänskliga strategier än backtracking för varje klass. Slutsatsen visar att det alltid är lönsamt att implementera de mänskliga strategier som rapporten har undersökt. 2

Abstract Sudoku solvers are a widely researched topic among mathematicians and computer scientists. This report investigates the differences in execution time and time complexity between backtracking and human strategies for classes with 17-21 clues. Backtracking is compared to our implementation of human strategies with test data that contains 99 Sudoku puzzles for each class. The study shows that the execution time and time complexity is improved for human strategies compared to backtracking for each class. The conclusion shows that it is always favorable to implement the human strategies investigated in the report. 3

Innehåll 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änskliga strategier..................... 8 3.2 Syfte.................................. 8 3.3 Problemformulering......................... 9 3.3.1 Avgränsningar........................ 9 4 Metod 10 4.1 Programmeringsspråk........................ 10 4.2 Sudokulösare med backtracking................... 10 4.3 Sudokulösare med mänskliga strategier och backtracking..... 11 4.4 Testdata................................ 12 5 Resultat 13 5.1 Backtracking............................. 13 5.2 Mänskliga strategier......................... 13 5.3 Jämförelse av körtid......................... 14 6 Analys & Diskussion 16 6.1 Metodkritik.............................. 17 7 Slutsats 18 4

1 Terminologi Nyckelord som används i uppsatsen: rutnät - Spelplanen som består av 9x9 celler. zon - En kvadratisk enhet som består av 3x3 celler. Zonerna är fördelade så att det finns tre zoner på varje rad. cell - En kvadratisk ruta som kan innehålla inget eller en siffra mellan 1-9. ledtråd - Antalet ifyllda celler i ett rutnät vid en given probleminstans. latinsk kvadrat - En matris där elementen är ordnade så att varje rad och varje kolumn innehåller element av olika typ. kandidat - tillåtet värde i en cell. 5

2 Introduktion Sudoku är ett pussel som går ut på att fylla ett rutnät med siffror. Rutnätet för ett standard Sudoku är 9x9 rutor stort och indelat i nio zoner på 3x3 rutor var. Varje probleminstans består av ett rutnät med ett antal från början kända siffror sådant att det finns en unik lösning. Det är problemlösarens uppgift att från detta utgångsläge färdigställa probleminstansen genom att fylla i resten av cellerna. En giltig lösning har hittats då varje rad, kolumn samt zon innehåller siffrorna 1-9 endast en gång. Detta är alltså precis som konstruktionen av en latinsk kvadrat. Figur 1: Probleminstans med giltig lösning. 6

3 Bakgrund 3.1 Tidigare forskning Sudoku är ett väl undersökt ämne inom forskningsvärlden mycket på grund av dess popularitet och matematiska egenskaper. McGuire et al. (2013) har visat att det finns 16 10 27 olika Sudoku. Vidare bevisade McGuire att det inte finns någon giltig Sudoku som innehåller färre än 17 ledtrådar. Kovacs (2012) har beskrivit olika typer av brute-force algoritmer och skillnaderna mellan dessa. Dessa algoritmer behöver i värsta fall testa alla möjliga lösningar tills en giltig lösning är funnen. Crook (2009) har undersökt en algoritm som är inspirerad av mänskliga strategier. Denna algoritm skiljer sig avsevärt från brute-force algoritmen eftersom den är kapabel till att göra smartare insättningar genom att utesluta otillåtna insättningar. Ett exempel är en probleminstans där en zon endast saknar en siffra. Brute-force algoritmen testar i värsta fall alla siffror från 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år systematiskt igenom alla tomma celler från vänster till höger och uppifrån ned. I den första tomma cellen sätter algoritmen in en etta. Om insättningen inte strider mot spelreglerna går algoritmen vidare till nästa tomma cell och sätter in en etta. Om detta leder till en konflikt ökar vi siffran för den senaste insättningen. Vid fallet då alla möjliga siffror leder till en konflikt backar algoritmen till den senaste fungerande insättningen och ökar dess värde med ett. Algoritmen fortsätter tills en lösning är hittad. Denna algoritm kallas för backtracking. Till skillnad från en totalsökningsalgoritm utvärderar inte denna alla möjliga, inklusive felaktiga, lösningsförslag utan letar sig sakta men säkert till den korrekta. Algoritmens värsta-falls-komplexitet är O(n m ) där n är antal alternativ för en cell och m är antalet tomma celler i probleminstansen. Mer specifikt blir tidskomplexiteten för ett standard Sudokupussel i värsta fallet O(9 m ). Detta eftersom varje tom cell innebär nio alternativ till lösningsförslag. I och med att en given ledtråd i en probleminstans innebär en tom cell mindre att fylla i växer körtiden för denna algoritm exponentiellt när antalet ledtrådar minskar. 3.1.2 Villkorsprogrammering Villkorsprogrammering är ett programmeringsparadigm i vilket ett antal variabler med givna domäner skall tilldelas värden i enlighet med ett antal villkor. Sudoku kan angripas med villkorsprogrammering där villkor dessutom liknar mänskliga strategier. Simonis (2005) har undersökt och redogjort för denna strategi. 7

3.1.3 Mänskliga strategier Davis (2012) har beskrivit strategier som människor använder när de löser Sudoku. Dessa strategier är grundade i människans förmåga att se mönster och utesluta alternativ. Vidare har Davis rangordnat dessa strategier efter hur svåra de är att applicera för en människa. Nedan följer de första fyra av Davis mänskliga strategier. Unik frånvarande kandidat: I fallet då en rad, kolumn eller zon innehåller åtta siffror återstår endast en möjlig kandidat och placeras därmed i den enda tomma cellen. Naken singel: I fallet då en specifik kandidat enbart kan placeras i en cell tillhörande en rad, kolumn eller zon placeras den i den cellen. Gömd singel: En gömd singel uppstår när en siffra endast finns som kandidat för en cell i en rad, kolumn eller zon. Det som skiljer en gömd singel från en naken singel är att cellen med den gömda singeln kan inneha flera kandidater. Låst kandidat: Det kan hända att det finns en zon i vilken en kandidat endast kan placeras i celler som faller inom en av de tre möjliga raderna eller kolumnerna. I och med att kandidaten måste finnas just i denna zon kan den uteslutas som kandidat från resten av raden eller kolumnen. I värsta fallet har en probleminstans från början varken någon unik frånvarande singel, naken singel, gömd singel eller låst kandidat. Om man då väljer att från detta stadie lösa probleminstansen med backtracking blir värsta-falls-komplexiteten även för denna algoritm O(9 m ). 3.2 Syfte Uppsatsen undersöker skillnader mellan två olika typer av Sudokulösare. Mer specifikt jämför uppsatsen förändringar i körtiden för dessa Sudokulösare med avseende på antalet ledtrådar i probleminstansen. Den första algoritmen tillämpar endast backtracking. Den andra algoritmen inleder med mänskliga strategier. När algoritmen inte kan gå vidare med mänskliga strategier använder den backtracking för att komplettera probleminstansen. Det finns inga belägg för att svårighetsgraden på en probleminstans ökar för människor när antalet ledtrådar minskar. Däremot tar det längre tid för backtracking algoritmen att lösa en probleminstans med färre ledtrådar eftersom det finns fler tomma celler att behandla. Uppsatsen undersöker därför om mänskliga strategier underlättar för en dator när antalet ledtrådar minskar. Denna insikt 8

skapar förutsättningar för att framtida problemlösare ska göra strategiska val när de skapar sin egen Sudokulösare. 3.3 Problemformulering Hur jämför sig körtiden för backtracking algoritmen mot körtiden för backtracking med mänskliga strategier i Sudokuproblemet med avseende på antalet ledtrådar? 3.3.1 Avgränsningar Vi kommer endast implementera tre av de beskrivna mänskliga strategierna. 1. Unik frånvarande singel 2. Naken singel 3. Gömd singel Probleminstanserna delas upp i 5 klasser där varje klass innehåller 99 probleminstanser. Testklasserna innehåller 17, 18, 19, 20 och 21 ledtrådar. 9

4 Metod 4.1 Programmeringsspråk Vi har valt att implementera algortimerna i Java som är ett objektorienterat högnivåsspråk. Även om Java inte presterar lika bra som ett kompilerat lågnivåsspråk som C eller C++ med avseende på körtid ger båda språken samma insikt eftersom det är förhållandet mellan körtiderna för de olika algoritmerna vi vill undersöka. Vidare är Java plattformsoberoende vilket underlättar replikation av vår undersökning. Vidare beräknas den genomsnittliga körtiden för respektive algoritm och resultaten sammanställs för analys. För att beräkna körtid används Javas inbyggda metod System.nanoTime(). Enligt Java-dokumentationen (2015) ger detta den mest precisa tidsmätningen. 4.2 Sudokulösare med backtracking 1 SudokuSolver(Matrix m): 2 Börja i det övre vänstra hörnet.; 3 foreach tom cell c i M do 4 for i 1:9 do 5 if i är en tillåten insättning 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ör backtracking algoritmen Backtracking algoritmen för Sudokuproblem har gjorts och publicerats tidigare (Stanford, 2008). Eftersom teorin bakom backtracking är trivial kan vi med fördel återanvända en befintlig implementation och därmed undvika att återuppfinna hjulet. Se pseudokoden från Stanford i figur 2. Backtracking algoritmen börjar i det övre vänstra hörnet och identifierar den första tomma cellen. Algoritmen undersöker här om en etta är en tillåten insättning. I fallet då insättningen inte är tillåten provar den istället nästa tal upp till 10

och med nio tills det går. I en probleminstans kan det finnas flera tillåtna insättningar i en tom cell. Givet en giltig probleminstans kommer ett av dessa tal garanterat vara en korrekt insättning. I fallet då insättningen i en tom cell är tillåten går algoritmen vidare och itererar samma process i nästa tomma cell. Här är det inte garanterat att någon av de nio siffrorna är korrekta eftersom den föregående insättningen kan vara tillåten men inte korrekt. I det fallet backar algoritmen till den föregående insättningen och inkrementerar den. Algoritmen fortsätter tills den har fyllt alla tomma celler med den korrekta insättningen. Denna algoritm är den som anses vara den mest primitiva algoritmen efter totalsökningsalgoritmen. Det är därför lämpligt att använda backtracking algoritmens körtid och komplexitet som referensvärde vid utvärdering av mänskliga strategier. 4.3 Sudokulösare med mänskliga strategier och backtracking 1 HumanWithBacktracking(Matrix m): 2 Skapa en kandidatlista för varje tom cell; 3 while Det finns celler med endast en kandidat i kandidatlistan do 4 Insättning av kandidat i cellen; 5 Borttagning av kandidat från kandidatlistorna i cellerna på raden; 6 Borttagning av kandidat från kandidatlistorna i cellerna på kolumnen; 7 Borttagning av kandidat från kandidatlistorna i cellerna på zonen; 8 end 9 Börja i det övre vänstra hörnet; 10 foreach tom cell c i M do 11 for i in kandidatlista do 12 if i är en tillåten insättning then 13 c i 14 if SudokuSolver(M) is true then 15 return true; 16 else 17 c 0; 18 end 19 end 20 end 21 return false; 22 end 23 return true; Figur 3: Pseudokod för mänskliga strategier med backtracking 11

Algoritmen med mänskliga strategier implementerar tre av Davis (2012) strategier: unik frånvarande singel, naken singel och gömd singel. Algoritmen skapar en kandidatlista för varje tom cell i probleminstansen. Sedan söker den efter de tomma celler vars kandidatlistor endast innehåller en kandidat. Den kandidaten sätts in i cellen. Sedan tas detta värde bort från kandidatlistorna för de tomma cellerna i samma rad, kolumn och zon. Som konsekvens kan detta leda till att fler celler härefter endast har en kandidat. Dessa fylls i på samma sätt. Denna process itereras tills inga fler celler har endast en kandidat. Därefter löses resten av probleminstansen med backtracking. Dessa strategier är de mest grundläggande ur ett implementationsperspektiv. Att undersöka dessa ger en inblick i hur mänskliga strategier påverkar körtiden. 4.4 Testdata För att besvara frågeställningen körs båda algoritmerna med samma testfall. För att ta hänsyn till anomalier bland probleminstanser behövs en stor mängd testdata för respektive grupp av pussel. Eftersom det inte finns probleminstanser med färre än 17 ledtrådar innehåller första klassen probleminstanser med 17 ledtrådar. För att se hur körtiderna förändras i takt med att antalet ledtrådar ökar undersöks även körtider för probleminstanser med 18 till 21 ledtrådar. Båda algoritmerna kräver en giltig probleminstans för att returnera en unik lösning. Alla testfall genereras därför med hjälp av Ericsons (2015) Sudokugenerator som beskriver en probleminstans med hjälp av siffror. Symbolerna - och! används som avskiljare för radslut och zonslut. Ericsons (2015) probleminstanser konverteras sedan till 2D vektorer i Java enligt formatet i figur 4. Figur 4: Indata för ett Sudokupussel med 17 ledtrådar. 12

5 Resultat 5.1 Backtracking Figur 5 visar den genomsnittliga körtiden för backtracking i nanosekunder för en probleminstans i respektive probleminstansklass. Ledtrådar Körtid (1 10 9 ns) 17 4.004 18 2.828 19 1.824 20 0.276 21 0.129 Figur 5: Genomsnittlig körtid per probleminstans för Sudokulösare med mänskliga strategier. 5.2 Mänskliga strategier Figur 6 visar den genomsnittliga körtiden för mänskliga strategier i nanosekunder för en probleminstans i respektive probleminstansklass. Figur 7 visar det högsta antalet singlar i en probleminstans och det genomsnittliga antalet singlar per probleminstans för varje klass. Figur 8 visar det genomsnittliga antalet kandidater som varje tom cell innehöll efter initialiseringen av probeminstansens kanddiatlistor. Ledtrådar Körtid (1 10 9 ns) 17 3.444 18 2.420 19 0.930 20 0.158 21 0.088 Figur 6: Genomsnittlig körtid per probleminstans för Sudokulösare med backtracking. Ledtrådar Högsta 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 Figur 7: Genomsnittlig fördelning av singlar över 99 probleminstanser för varje klass. 13

Ledtrådar 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änskliga strategier. 5.3 Jämförelse av körtid Figur 9 visar förhållandet mellan de genomsnittliga körtiderna för backtracking och mänskliga strategier. De blå staplarna visar körtider för backtracking. De gula staplarna visar körtider för mänskliga strategier. Figur 10 visar den procentuella minskningen av körtid för mänskliga strategier jämfört med backtracking. Figur 9: Körtider backtracking (blå) jämfört med mänskliga strategier (gul) 14

Figur 10: Procentuell minskning av körtid med mänskliga strategier. 15

6 Analys & Diskussion Körtiderna för båda algoritmerna minskar när antalet ledtrådar ökar. Detta beror på att båda algoritmerna har färre tomma celler att behandla. I figur 9 och 10 ser vi att mänskliga strategier ger en förbättrad körtid för varje probleminstansklass. Detta innebär att vår implementation av Davis (2012) första tre mänskliga strategier har varit gynnsamma. I figur 8 ser vi att det genomsnittliga antalet kandidater per ruta minskar när antalet ledtrådar ökar. Mer intressant är att antalet kandidater per ruta halveras när mänskliga strategier har eliminerat de alternativ som leder till konflikt. Antalet kandidater per ruta för samtliga probleminstansklasser ligger inom intervallet (4,5). Mänskliga strategier algoritmen går därefter vidare med backtracking och har då i snitt 4-5 kandidater att prova. Detta ger en genomsnittlig tidskomplexitet på nära O(4 m ) för probleminstanser med 21 ledtrådar och en genomsnittlig tidskomplexitet på närmare O(5 m ) när antalet ledtrådar går mot 17. Det är en av orsakerna till den förbättring av körtid som uppstår när mänskliga strategier används jämfört med backtracking som alltid har en tidskomplexitet på O(9 m ). Den markanta skillnaden mellan algoritmernas tidskomplexitet översätts dock inte direkt till exponentiellt bättre körtid. Det tar tid för algoritmen med mänskliga strategier att förminska antalet tomma celler i indatat innan den påbörjar backtracking. Se hur algoritmen itererar över alla celler i probleminstansen och skapar en kandidatlista i kodavsnittet nedan. Den modifierade backtracking som algoritmen med mänskliga strategier använder är dessutom långsammare än enbart backtracking. Detta beror på att algoritmen itererar över alla tomma celler i probleminstansen och söker efter celler som endast har en kandidat. När den kandidaten fylls i itererar algoritmen över alla tomma celler i samma rad, kolumn och zon som den ifyllda cellen och tar bort den ifyllda siffran ifall den finns i de andra cellenrnas kandidatlista. Se även detta i kodavsnittet nedan. Det är många operationer som backtracking algoritmen inte gör. Däremot behöver algoritmen med mänskliga strategier endast iterera över kandidater för varje tom cell jämfört med backtracking algoritmen som itererar över alla tal från ett till nio. Som konsekvens blir körtiden bättre med mänskliga 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) { 10 cmatrix[i][j] = new Candidates(); 11 removecandidates(grid,i,j); 16

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örtidstrenden för båda algoritmerna går mot kortare körtider. Störst förbättring mellan algoritmerna sker vid problemsinstanser med 19 ledtrådar. Mänskliga algoritmer ger där en körtid som är 49% bättre än backtracking. Det kan bero på att vår testdata innehåller olika jämn spridning av ledtrådar i de olika testklasserna eller innehåller olika många probleminstanser som går att lösa snabbt. För att få svar på varför skillnaden är störst vid probleminstanser med 19 ledtrådar rekommenderar vi en undersökning av hur spridningen av ledtrådar påverkar körtiden för båda algoritmerna. Alternativt kan fler testfall användas för att jämna ut skillnaden mellan enskilda probleminstanser och därmed minska variansen. 6.1 Metodkritik För att potentiellt förbättra körtiden kan fler av Davis mänskliga strategier implementeras. Det är dock viktigt att väga tidskostnaderna för de nya strategierna mot resultatet. En ineffektiv implementation kan leda till högre tidskomplexitet och därmed försämrad körtid. Metoden kan också utvidgas till att undersöka probleminstansklasser med fler ledtrådar. Det är nödvändigt att undersöka om körtidstrenden fortsätter när antalet ledtrådar ökar eller om det finns en punkt då tidsvinsten är försumbar. I det senare fallet vore det till exempel mer ekonomiskt med avseende på minne att använda backtracking algoritmen. I denna undersökning används enbart 99 testfall för varje probleminstansklass. Det är en liten andel av antalet probleminstanser som existerar för Sudokuproblemet. För att öka trovärdigheten i resultaten bör därför fler testfall användas när Sudokulösare undersöks. 17

7 Slutsats Körtiden för mänskliga strategier är avsevärt bättre än backtracking för alla probleminstansklasser som rapporten undersökt. Detta beror på att tidskomplexiteten för mänskliga strategier blir mindre än för backtracking. Störst skillnad mellan algoritmerna uppstår vid probleminstanser med 19 ledtrådar. För probleminstanser med 20 och 21 ledtrådar blir den absoluta tidsskillnaden mindre men den procentuella förbättringen är fortfarande betydande. Undersökningen har därmed visat att det lönar sig att implementera de mänskliga strategier som rapporten undersökt mot att endast använda backtracking vid konstruktion av en Sudokulösare. 18

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 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. [7] Julie Zelenski. Lecture 11: Programming abstractions. University Lecture, Stanford University, 2008. 19

www.kth.se