Solver now returns paths along with words

* Updated/improved tests and examples
* Dictionary loads a lot faster now
* Added timing for dictionary

Author: mwatson

README.md

@@ -1,7 +1,7 @@
 BoggleSolver
 ----
 
-This is a PHP class that solves Boggle. I made it for fun.
+This is a PHP class that solves Boggle boards. I made it for fun.
 
 ## Installing
 
@@ -31,7 +31,7 @@ try {
         "A M T O".
         "L N S T".
         "L X T G".
-        "E T A N";
+        "E T A N"
     );
 } catch (\BoggleSolver\BoggleException $e) {
     die("exiting on error: " . $e->getMessage());
@@ -41,6 +41,27 @@ try {
 $words = $boggle->findWords();
 ````
 
+`BoggleSolver::findWords()` will return an array where every valid word is the key 
+and the value is one or more arrays describing the path you take on the board to 
+replicate finding this word.
+
+Example (in formatted JSON, for clarity):
+
+```json
+{
+    "ANTS":[
+        [0,5,2,6],
+        [0,5,10,6],
+        [14,15,10,6]
+    ],
+    "ANTA":[
+        [0,5,10,14]
+    ]    
+}
+```
+
+The numbers in the array represent each tile ID.
+
 See the files in the `examples` directory for more info.
 
 ## Tests
@@ -59,4 +80,5 @@ will delete the coverage directory.
 
 © Mike Watson
 
-Released under the [MIT license](http://opensource.org/licenses/MIT). See the `LICENSE` file.
+Released under the [MIT license](http://opensource.org/licenses/MIT). See the 
+`LICENSE` file.

examples/example01.php

@@ -38,11 +38,12 @@
 
 echo "Found {$numWords} words:\n\n";
 
-foreach ($words as $word) {
-    echo $word . "\n";
+foreach ($words as $word => $paths) {
+    echo "{$word}\n";
 }
 
 echo "\n";
 
 // lastSolveTime will hold the time it took to solve
-echo "Solved in {$boggle->lastSolveTime} seconds\n";
+echo "Dictionary built in {$boggle->lastDictTime} seconds\n";
+echo "Board solved in {$boggle->lastSolveTime} seconds\n";

examples/example02.php

@@ -22,13 +22,12 @@
 
 $words = $boggle->findWords();
 
-
 echo "Boggle Board:\n\n";
 echo $boggle->displayBoard();
 
 echo "\n";
 
-foreach ($words as $word) {
+foreach ($words as $word => $paths) {
     echo $word . "\n";
 }
 

src/BoggleSolver.php

@@ -10,6 +10,7 @@ class BoggleSolver
     public $board = array();
     public $boardLookup = array();
 
+    public $lastDictTime;
     public $lastSolveTime;
 
     // for now, 3 - 11 letter words only
@@ -22,8 +23,12 @@ class BoggleSolver
         'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw',
     );
 
-    public function __construct()
+    // $dictFile should be relative to this file
+    public function __construct($dictFile = "")
     {
+        if ($dictFile) {
+            static::$dictFile = $dictFile;
+        }
     }
 
     public function getWords()
@@ -33,11 +38,13 @@ public function getWords()
 
     public function loadDict()
     {
+        $start = microtime(true);
+
         $this->dict = array();
         $words = $this->getWords();
 
-        // Create a boggle friendly lookup table. This is basically a half-assed 
-        // search tree so we know when we can stop checking for words on the 
+        // Create a boggle friendly lookup table. This is basically a half-assed
+        // search tree so we know when we can stop checking for words on the
         // current path.
         foreach ($words as $word) {
 
@@ -46,26 +53,24 @@ public function loadDict()
                 continue;
             }
 
+            $wordLen = strlen($word);
+
             // max length is mostly here for memory reasons
-            if (strlen($word) < static::$minLen) {
+            if ($wordLen < static::$minLen) {
                 continue;
             }
-            if (strlen($word) > static::$maxLen || strlen($word) > $this->size * $this->size) {
+            if ($wordLen > static::$maxLen) {
+                continue;
+            }
+            if ($wordLen > $this->size * $this->size) {
                 continue;
             }
 
             $ptr = &$this->dict;
 
-            for ($i = 0; $i <= static::$maxLen; $i++) {
-                if ($i == strlen($word)) {
-                    $ptr[] = $word;
-                    continue;
-                } else if ($i > strlen($word)) {
-                    continue;
-                }
-
+            for ($i = 0; $i < $wordLen; $i++) {
                 $letter = $word[$i];
-                if ($letter == 'Q' && $word[$i + 1] == 'U') {
+                if ($letter == 'Q' && isset($words[$i + 1]) && $word[$i + 1] == 'U') {
                     $letter = 'Qu';
                     $i++;
                 }
@@ -74,9 +79,12 @@ public function loadDict()
                 }
                 $ptr = &$ptr[$letter];
             }
+            $ptr[] = $word;
         }
 
         unset($words);
+
+        $this->lastDictTime = microtime(true) - $start;
     }
 
     public function loadBoard($board)
@@ -157,6 +165,9 @@ public function displayBoard($lineEnd = "\n")
             $colPtr = $rowPtr;
             while ($colPtr !== null) {
                 $board .= $colPtr->letter;
+                if ($colPtr->letter != "Qu") {
+                    $board .= " ";
+                }
                 $colPtr = &$colPtr->e;
             }
             $board .= $lineEnd;
@@ -181,7 +192,7 @@ public function findWords()
 
             $words = array_merge(
                 $words,
-                $this->findWordsFromOneTile($ptr, null)
+                $this->findWordsFromOneTile($ptr, null, $words)
             );
 
             $ptr->visited = false;
@@ -200,10 +211,10 @@ public function findWords()
 
         $this->lastSolveTime = microtime(true) - $start;
 
-        return array_keys($words);
+        return $words;
     }
 
-    public function findWordsFromOneTile($boardPtr, $dictPtr = null, $words = array())
+    public function findWordsFromOneTile($boardPtr, $dictPtr = null, &$words = array(), $path = array())
     {
         if ($dictPtr === null) {
             $dictPtr = &$this->dict;
@@ -215,10 +226,15 @@ public function findWordsFromOneTile($boardPtr, $dictPtr = null, $words = array(
             return array();
         }
 
+        $path[] = $boardPtr->id;
+
         $dictPtr = &$dictPtr[$curLetter];
 
         if (isset($dictPtr[0])) {
-            $words[$dictPtr[0]] = 1;
+            if (!isset($words[$dictPtr[0]])) {
+                $words[$dictPtr[0]] = array();
+            }
+            $words[$dictPtr[0]][] = $path;
         }
 
         foreach (static::$dirs as $dir) {
@@ -229,12 +245,12 @@ public function findWordsFromOneTile($boardPtr, $dictPtr = null, $words = array(
                 continue;
             }
 
-            // if we're going diagonal, make sure the two adjacent tiles 
+            // if we're going diagonal, make sure the two adjacent tiles
             // haven't already been pathed to each other
             if (strlen($dir) == 2) {
-                $d1 = $dir[0];
-                $d2 = $dir[1];
-                if ($boardPtr->$d1->pathTo == $boardPtr->$d2->id || 
+                $d1 = substr($dir, 0, 1);
+                $d2 = substr($dir, 1, 1);
+                if ($boardPtr->$d1->pathTo == $boardPtr->$d2->id ||
                     $boardPtr->$d2->pathTo == $boardPtr->$d1->id
                 ) {
                     continue;
@@ -246,7 +262,7 @@ public function findWordsFromOneTile($boardPtr, $dictPtr = null, $words = array(
             $boardPtr->$dir->pathTo = $boardPtr->id;
             $boardPtr->pathTo = $boardPtr->$dir->id;
 
-            $newWords = $this->findWordsFromOneTile($boardPtr->$dir, $dictPtr, $words);
+            $newWords = $this->findWordsFromOneTile($boardPtr->$dir, $dictPtr, $words, $path);
             $words = array_merge($words, $newWords);
 
             // unset those flags since we're picking a new path after this