Please help with Boggle game

Question

The Input
The input file is exactly as in WordSearch.java and in fact, you can reuse almost the entire program, especially the routines to read the word and puzzle files. In order to limit the amount of output words that are less than nine characters are not to be considered matches.
Strategy
First, provide a Position class to store a row and column as a pair, and provide a constructor, toString, and equals (hashCode would also be good to have, but is not needed). Make sure Position is an immutable type.
Next, change solvePuzzle to solveBoggle as follows:
     * Routine to solve the Boggle game.
     * @return a Map containing the strings as keys, and the positions used
     *     to form the string (as a List) as values
    public Map solveBoggle( )
        Map results = new HashMap( );
        List path = new ArrayList( );
        for( int r = 0; r < rows; r++ )
            for( int c = 0; c < columns; c++ )
                solve( new Position( r, c ), "", paths, results );
        return results;
    }Observe that solveBoggle calls the routine solve for each position in the grid. solve is recursive, and implementing it is virtually the entire assignment. After you implement solve you should have a routine that can print out, in a nice form, the Map returned by solveBoggle.
The specification for the recursive solve routine is:
     * Hidden recursive routine.
     * @param thisPos the current position
     * @param charSequence the characters in the potential matching string thusfar
     * @param path the List of positions used to form the potential matching string thusfar
     * @param results the Map that contains the strings that have been found as keys
     *       and the positions used to form the string (as a List) as values.
    private void solve( Position thisPos, String charSequence, List path, Map results )
        /* Less than one page of code will do it. */
    }In implementing solve you will want to do the following:
Attach the character at thisPos to charSequence.
If the resulting current string is not a prefix of any word in the dictionary, you can return.
Otherwise, you will want to update the path variable, and look for some matches.
If the current string is a word in the dictionary you want to update the map.
In any event, you want to recursively call solve with appropriate parameters, on all adjacent positions, skipping those that have already been used in the current string, and being careful not to wander off the end of the board.
Don't forget to update the path variable when you return from solve.
Copying and Cloning
As much as possible, you should avoid making copies of variables. In particular, the last two parameters to solve (the List and Map are to be the same object for each unique invocation of solveBoggole. YOU MAY NOT MOVE THEM TO BE CLASS VARIABLES. However, what this means is that when you put a String as a key and a List as a value into the Map, you will need at that point to make a copy of the List, since otherwise the Map would simply be storing lots of references to the same single list (which would be empty at the end of the program). You can use any of the List (subclasses) constructors to create a List from another List.
This is the puzzle file:
fozepdkdnqlhfejdzksccfykdxnlorwvfwavbmyqclxjrgntqhvuowgrtufhnbdt
zfqatqryeqhxxuqpdmmsksjdooncssvrznssflsjbahawxsalesvwdblsqpkimdj
zxdeiwqmwxouwgukkmfjqiwkynwizztyxxehtuvrtklqsgaduhomsmyszwbywwyv
teeozafumtmebojvwxkqliimhlmfikabpgsqizkuszztnirlibbtlkgsvuzdfbhw
iboqaaltzkmnsdycgawukeohyonfpwdxxrqxubqtnfghkhkrhintobcorpwhlzgi
tyinbyiofryqykjhswcizgwrwsajuiuphceicmzifxyfjhodfqlexhxvcxgyganp
erxhfyrnxpsgyhjdzuhyefviecgkcvbhozqvzhixyddwkpzllikrpfzuhhgmeivu
jlqiuafsdlopapbnxlfnsehaopmsxjpgufpofwglhwajlbxkmcxfighwwvrtegca
nroupwfxugifhfpwjpdsxmqthjpnrrngkdbzbgyvojcwqtuakzuilmbuyshplwwv
bzxcfxzugdszwozhnvryhushnbxyxvwyuvcbsbxbgpccfblsyeshzmpmnommjimf
fogarebxvdcbgpvguonvachqsvebgrglhplbvoaqtetzuphqdvlfzuxsrcvxvele
twfolgggmaigppyumlbmhzgzdbwyfhcagiqtqxzcxhlmxlilxjxeiddlhclolopr
yfmqemubvhputxgsjdwtjchsgsirixlifxyljvnhccbxchplnogysnsygapqaazh
azsluhszmwwofobuchuuxmsdpjtpmuyouqzoaupmqmavcdqemkajzuoqfkftefhy
xhpxbejrslouogadtcmsydienpxrwfstojrppaiioyecfhhylwskzcomtnfpuzii
izzycjiqiounxcnjaftzjjncyurtuzdebfedomvybrnavajvhewqnjsogljclmgo
tltizoicfwdbwmygrvwggrumcdopsxdliwvjmemuapxydvewsddzwznyfcozztmj
siseogaqvxozvvxnaamwcawjemkfgwqaekesrfioeznzwnnwpburdqchdmoljelp
priiyswdtmepztnovhiaakkfzyqifdxwuhetcayvmcnlwcctkkvmufrtejdlmdhi
klbonbmagzncbpxnbszwasrgbxrpayymlbbydnyjoonpfmfhgedgzwmatdsvdqio
rjnuwnfkdsbjegqlnvrmrgonlgiryqfqbumzkslnknwrvmckjvwddnqpvagutnkw
kwwuqhjbwguuuyegtdjzsbqnbyhwnttxsrtiadlxlfthdxnzcwauxqiborzbnubf
lupmzblkieumdhnigncdfmgtgiwtcxaoupctqngbtanyhcinrntwzbphjnconceh
ugckvinqiaqsezhvmcrneivpyxdlcjswpuimfwcpythfuragtutzeqrcqupsgjqv
gyilwmavhkabbchuwdudtlhlhxdngtlmuvxqhanrkpslscfqfbtaodmyarlinyvh
tuzdupugeorwqzpvakyrnkpnbcwobtxwnzbkoxqsmkrcjgalqyceittlwrczkzxa
yzmmwehioynzenlwlpatjwghnigaidcieoxdueljeakknvgyljtwhaduklwuqydv
ocylglummewbceapnvnuxqridpctqhoejorrcldqsbrwgtnvraqoqjytydookdvw
tmnxatnuuhsacfwtfokvzkqxpeoajlyfxlczgstbbnddszzxpluoxkmnrcpcnnhm
ammhehifvlknnjlcwfrusfhljwnwjxiljwspeaubogobqbfojyiddpqondkycvkn
recxfyyvfpyxqdlbcwehnuwbaibcdlqxquuxttuyisxyxicbggludjvfrwjxkbuc
wobrhvprposmyuqfcbzhkumdswaezwivljmugdmxrekqycxadwipswsmsvrsrzpc
lexrhlpbpbtpfqpimzxgwrsqmjkelciyghrpsiqhjlwqboyppxxnrqgdbsjousmc
besumkdywaozqprfmovfgbjituwqolsqpmkbxnzvpquffnnteizklkueetutepjv
bvwykytaqqhvfwojgnurxqyejuxpjiklfjlpjhrzzbuexkqeamvzctdoocdzmqmr
bajkjajibfozpefrqcrvywjobonngafhcorlqcvshjtzqaqicjdagmohdewjgbti
rkvknqewbxvrzoabxdefsuoxalggmzqgmlsbbwxfvvwulyxicbqwyetypbhedxmp
jeqmaprvmqrxooissyoqchqslxyovkdgovuomolzecyssglmgbejjvduubiplnxb
kspwicxmgyeyernltrwembahckypxyqhshfalfmrdsrhmeuhwslkvltzxuouugdm
pkoapcrsulcipypntcaoptompcijlnxaylbnnuikfksxkkmdmmseigqzkbjvogym
sbchvkrdwkcgwokkdconkhmuixswgqlarphobztxlvdjmptptiedrsazquxykkyd
zhtainzvkfewuynqirvzkvacpzcbkagljcmsrnpbsuypulfefafpyhtpgvtqxbcg
dqaudswyownkjsoouvfscykkvdbsefbkxdgcveajantkhjacegwiggtclwusdxcc
bkeyphirwddepegvkeeslzuyxrqcouerfkquranofruuvaqhgwzrxuquniwbdcti
mjeglrwqiqlfsdoyzoswkksxsoyvqtfeejkpdiinyvtsyhtxxlvhvngpdhlvaqbh
coyhwguxbppbzkawvvgskmipvtmylofpcfwymtxpiprhzrgvpopbaxrysdwgrdvv
iuwwntmviffiwlfnzwpbugbolxwfaualoyhdsvycafmzsrmtqbxkjyavyxcarclh
btkvokxrskqkdcgtgdfpbimbfocytnhwitrzdqqvagigkobqthiwrwywlawgnfcy
yvxdlnbmvjufzvyseiovemtrorxewbcwwzaiobwjmsolnoduwtpdglwucuybxcxu
bzepaaamspxhfcdewthegdaizblxdlthkzwlbxzvoxcvbgzxbgdhmerlhfkkqfra
eqnfpnadmfynlynogqxswqgdvsqlyhocxbkmokrapsqcsdsyvptugzzdtpprxfww
gglxsezkwpoouhpqyikgjjkebbwyguwoajluolekcvbxeqpcabllmxpnynnghkuj
tgejtkwvfxujpjmrkzexwtkujycqkwafcgpxqlvwkpfzztsjswgqrtmatotdltkp
bznrminyxvxyopijnqzfjmfcayhntsdutsoicdgzygapxiylazqknxooyybrsgol
yevahecgkcvjmvumwmykkpyinbbfkrsivqlfupletinffktbwslijlswpwdzpxjn
nwshlfnepdlupfxlzjwiwognkloaianywhhkmvobaaxphucgfyqcnwrzhgbrgqpe
xxolufmuhjjoelwlmmnbiharneivwyzuvqfrvulcfwsjjovvakwktzbidjdbjfvg
vdxszkwegoqqenlexkqtjrbocfpmmnujssbrezvlnlbryoxyanrjguzibrwnetyy
nbprakcpyfgywfwwupiakjllajbgczerbtjbgnrgtzerhdnbuxeehrshatqfuuwv
qhzwvqeorihanueiuimbzgkbbagwxfrnmqjhinxcxeclbgtvqhyrqitrlbnigfvv
xgeivcmuiohlxagpkgharcrcdhmmojhlrlvophiyyqjvssmeatervyvbfhntswgj
jcxzlizjykgsetxfmbykbulibyduwkffodgzlhjlupdakahxeghfasqdstzodfvt
kctxleifvnggonfutobvgrzalyoqfjkrnfozlyegmmocctwvhztprspesfuargrg
lgfwemfsatucpsywurollfrflnfeuxkhfsgleleegahvvhupakanptsagaeaxrke
the dictionary file is too big to post but it is something like this:
a
aah
aardvark
aardvarks
aardwolf
aardwolves
aba
abaca
abaci
aback
abacterial
abacus
abacuses
abaft
abalone
abalones
abandon
abandoned
abandoning
abandonment
abandons
abase
abased
abasement
abasements
abases
abash
abashed
abashes
abashing
abashment
abashments
abasing
abatable
abate
abated
abatement
abater
abaters
abates
abating
abatis
abatises
abattoir
abattoirs
abaxial
abbacies
abbacy
abbe
abbess
abbey
abbot
abbots
abbreviate
abbreviated
abbreviates
abbreviating
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
// WordSearch class interface: solve word search puzzle
// CONSTRUCTION: with no initializer
// ******************PUBLIC OPERATIONS******************
// int solvePuzzle( )   --> Print all words found in the
//                          puzzle; return number of matches
public class WordSearch
     * Constructor for WordSearch class.
     * Prompts for and reads puzzle and dictionary files.
    public WordSearch( ) throws IOException
        puzzleStream = openFile( "Enter puzzle file" );
        wordStream   = openFile( "Enter dictionary name" );
        System.out.println( "Reading files..." );
        readPuzzle( );
        readWords( );
     * Routine to solve the word search puzzle.
     * Performs checks in all eight directions.
     * @return number of matches
    public int solvePuzzle( )
        int matches = 0;
        for( int r = 0; r < rows; r++ )
            for( int c = 0; c < columns; c++ )
                for( int rd = -1; rd <= 1; rd++ )
                    for( int cd = -1; cd <= 1; cd++ )
                        if( rd != 0 || cd != 0 )
                            matches += solveDirection( r, c, rd, cd );
        return matches;
     * Search the grid from a starting point and direction.
     * @return number of matches
    private int solveDirection( int baseRow, int baseCol, int rowDelta, int colDelta )
        String charSequence = "";
        int numMatches = 0;
        int searchResult;
        charSequence += theBoard[ baseRow ][ baseCol ];
        for( int i = baseRow + rowDelta, j = baseCol + colDelta;
                 i >= 0 && j >= 0 && i < rows && j < columns;
                 i += rowDelta, j += colDelta )
            charSequence += theBoard[ i ][ j ];
            searchResult = prefixSearch( theWords, charSequence );
            if( searchResult == theWords.length )
                break;
            if( !((String)theWords[ searchResult ]).startsWith( charSequence ) )
                break;
            if( theWords[ searchResult ].equals( charSequence ) )
                numMatches++;
                System.out.println( "Found " + charSequence + " at " +
                                    baseRow + " " + baseCol + " to " +
                                    i + " " + j );
        return numMatches;
     * Performs the binary search for word search.
     * @param a the sorted array of strings.
     * @param x the string to search for.
     * @return last position examined;
     *     this position either matches x, or x is
     *     a prefix of the mismatch, or there is no
     *     word for which x is a prefix.
    private static int prefixSearch( Object [ ] a, String x )
        int idx = Arrays.binarySearch( a, x );
        if( idx < 0 )
            return -idx - 1;
        else
            return idx;
     * Print a prompt and open a file.
     * Retry until open is successful.
     * Program exits if end of file is hit.
    private BufferedReader openFile( String message )
        String fileName = "";
        FileReader theFile;
        BufferedReader fileIn = null;
        do
            System.out.println( message + ": " );
            try
                fileName = in.readLine( );
                if( fileName == null )
                     System.exit( 0 );
                theFile = new FileReader( fileName );
                fileIn  = new BufferedReader( theFile );
            catch( IOException e )
              { System.err.println( "Cannot open " + fileName ); }
        } while( fileIn == null );
        System.out.println( "Opened " + fileName );
        return fileIn;
     * Routine to read the grid.
     * Checks to ensure that the grid is rectangular.
     * Checks to make sure that capacity is not exceeded is omitted.
    private void readPuzzle( ) throws IOException
        String oneLine;
        List puzzleLines = new ArrayList( );
        if( ( oneLine = puzzleStream.readLine( ) ) == null )
            throw new IOException( "No lines in puzzle file" );
        columns = oneLine.length( );
        puzzleLines.add( oneLine );
        while( ( oneLine = puzzleStream.readLine( ) ) != null )
            if( oneLine.length( ) != columns )
                System.err.println( "Puzzle is not rectangular; skipping row" );
            else
                puzzleLines.add( oneLine );
        rows = puzzleLines.size( );
        theBoard = new char[ rows ][ columns ];
        Iterator itr = puzzleLines.iterator( );
        for( int r = 0; r < rows; r++ )
            String theLine = (String) itr.next( );
            theBoard[ r ] = theLine.toCharArray( );
     * Routine to read the dictionary.
     * Error message is printed if dictionary is not sorted.
    private void readWords( ) throws IOException
        List words = new ArrayList( );
        String lastWord = null;
        String thisWord;
        while( ( thisWord = wordStream.readLine( ) ) != null )
            if( lastWord != null && thisWord.compareTo( lastWord ) < 0 )
                System.err.println( "Dictionary is not sorted... skipping" );
                continue;
            words.add( thisWord );
            lastWord = thisWord;
        theWords = words.toArray( );
      // Cheap main
    public static void main( String [ ] args )
        WordSearch p = null;
        try
            p = new WordSearch( );
        catch( IOException e )
            System.out.println( "IO Error: " );
            e.printStackTrace( );
            return;
        System.out.println( "Solving..." );
        p.solvePuzzle( );
    private int rows;
    private int columns;
    private char [ ][ ] theBoard;
    private Object [ ] theWords;
    private BufferedReader puzzleStream;
    private BufferedReader wordStream;
    private BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );
}Thank you in advance

Answer 1

Ok, I'm stuck. Please somebody. It seems like I'm not moving inside the board. This is what I have done so far:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
public class WordSearch
     * Constructor for WordSearch class.
     * Prompts for and reads puzzle and dictionary files.
    public WordSearch( ) throws IOException
        puzzleStream = openFile( "Enter puzzle file" );
        wordStream   = openFile( "Enter dictionary name" );
        System.out.println( "Reading files..." );
        readPuzzle( );
        readWords( );
       * Private class Position is a class to store a row and a column
       * as a pair.
    private class Position
         int row;
         int column;
            * A constructor from two integers
            * @param r is the row of the position
            * @param c is the column of the position
         Position( int r, int c )
              row = r;
              column = c;
            * First accessor
            * @return the row as an int
          public int getRow( )
               return row;
            * Second accessor
            * @return the column as an int
          public int getColumn( )
               return column;
            * Position objects are equal if both rows and columns are equal
             * @return true if both rows and columns are equal; false otherwise
          public boolean equals( Object aPosition )
               int x = ( (Position) aPosition ).getRow( );
               int y = ( (Position) aPosition ).getColumn( ); 
             return ( ( row == x ) && ( column == y ) );
            * Returns a String representation of Position
               * @return a String with Position as ( x, x )
          public String toString( )
             return ( "( " + row + ", " + column + " )" );
    } // end of Position
     * Routine to solve the Boggle game.
     * @return a Map containing the strings as keys, and the positions
     * used to form the string (as a List) as values
    public Map solveBoggle( )
        Map results = new HashMap( );
        List path = new ArrayList( );
        boolean[][] marked = new boolean[rows][columns];
        for( int r = 0; r < rows; r++ )
             for( int c = 0; c < columns; c++ )
                solve( new Position( r, c ), "", path, results, marked);
        return results;
     * Hidden recursive routine.
     * @param thisPos the current position
     * @param charSequence the characters in the potential matching string thusfar
     * @param path the List of positions used to form the potential matching string thusfar
     * @param results the Map that contains the strings that have been found as keys
     * and the positions used to form the string (as a List) as values.
    private void solve( Position thisPos, String charSequence, List path, Map results,
              boolean[ ][ ] marked )
         int row = thisPos.getRow( );
         int col = thisPos.getColumn( );
         charSequence += theBoard[ row ][ col ];
        int searchResult = prefixSearch( theWords, charSequence );
        if( searchResult == theWords.length )
               return;
          if( theWords[ searchResult ].equals( charSequence ) )
             path.add( thisPos );
             results.put( charSequence, path );
             path.clear( );
             charSequence.replaceAll( charSequence, "" );
             return;
        if( !( (String)theWords[ searchResult ] ).startsWith( charSequence ) )
             return;
        else
             path.add( thisPos );
             marked[ thisPos.getRow( ) ][ thisPos.getColumn( ) ] = true;     
               if( ((row-1) >= 0) && ((col-1) >= 0) && !marked[row-1][col-1] )
                    marked[row-1][col-1] = true;
                    solve( new Position(row-1, col-1), charSequence, path, results, marked);
               if( ((row-1) >= 0) && !marked[row-1][col] )
                    marked[row-1][col] = true;
                    solve( new Position(row-1, col), charSequence, path, results, marked);
               if( ((row-1) >= 0) && ((col+1) < columns) && !marked[row-1][col+1]  )
                    marked[row-1][col+1] = true;
                    solve( new Position(row-1, col+1), charSequence, path, results, marked);
               if( ((col-1) >= 0) && !marked[row][col-1]  )
                    marked[row][col-1] = true;
                    solve( new Position(row, col-1), charSequence, path, results, marked);
               if( ((col+1) < columns) && !marked[row][col+1] )
                    marked[row][col+1] = true;
                    solve( new Position(row, col+1), charSequence, path, results, marked);
               if( ((row+1) < rows) && ((col-1) >= 0) && !marked[row+1][col-1] )
                    marked[row+1][col-1] = true;
                    solve( new Position(row+1, col-1), charSequence, path, results, marked);
               if( ((row+1) < rows) && !marked[row+1][col] )
                    marked[row+1][col] = true;
                    solve( new Position(row+1, col), charSequence, path, results, marked);
               if( ((row+1) < rows) && ((col+1) < columns) && !marked[row+1][col+1] )
                    marked[row+1][col+1] = true;
                    solve( new Position(row+1, col+1), charSequence, path, results, marked);
     * Performs the binary search for word search.
     * @param a the sorted array of strings.
     * @param x the string to search for.
     * @return last position examined;
     *     this position either matches x, or x is
     *     a prefix of the mismatch, or there is no
     *     word for which x is a prefix.
    private static int prefixSearch( Object [ ] a, String x )
        int idx = Arrays.binarySearch( a, x );
        if( idx < 0 )
            return -idx - 1;
        else
            return idx;
     * Print a prompt and open a file.
     * Retry until open is successful.
     * Program exits if end of file is hit.
    private BufferedReader openFile( String message )
        String fileName = "";
        FileReader theFile;
        BufferedReader fileIn = null;
        do
            System.out.println( message + ": " );
            try
                fileName = in.readLine( );
                if( fileName == null )
                     System.exit( 0 );
                theFile = new FileReader( fileName );
                fileIn  = new BufferedReader( theFile );
            catch( IOException e )
              { System.err.println( "Cannot open " + fileName ); }
        } while( fileIn == null );
        System.out.println( "Opened " + fileName );
        return fileIn;
     * Routine to read the grid.
     * Checks to ensure that the grid is rectangular.
     * Checks to make sure that capacity is not exceeded is omitted.
    private void readPuzzle( ) throws IOException
        String oneLine;
        List puzzleLines = new ArrayList( );
        if( ( oneLine = puzzleStream.readLine( ) ) == null )
            throw new IOException( "No lines in puzzle file" );
        columns = oneLine.length( );
        puzzleLines.add( oneLine );
        while( ( oneLine = puzzleStream.readLine( ) ) != null )
            if( oneLine.length( ) != columns )
                System.err.println( "Puzzle is not rectangular; skipping row" );
            else
                puzzleLines.add( oneLine );
        rows = puzzleLines.size( );
        theBoard = new char[ rows ][ columns ];
        Iterator itr = puzzleLines.iterator( );
        for( int r = 0; r < rows; r++ )
            String theLine = (String) itr.next( );
            theBoard[ r ] = theLine.toCharArray( );
     * Routine to read the dictionary.
     * Error message is printed if dictionary is not sorted.
    private void readWords( ) throws IOException
        List words = new ArrayList( );
        String thisWord;
        while( ( thisWord = wordStream.readLine( ) ) != null )
            words.add( thisWord );          
        theWords = words.toArray( );
        Arrays.sort( theWords );
       * Prints a String representation of the words found and their List of positions.  
       * @Prints a String with the words found and their List of positions.
    public static void printMap( Map wordMap )
         Iterator itr1 = wordMap.entrySet( ).iterator( );
         String str = "";        
        while( itr1.hasNext( ) )
             String aWord = (String)( (Map.Entry)itr1.next( ) ).getKey( );  
             str += "Found " + aWord + " at ";
             Iterator itr2 = ( (List)( ( (Map.Entry)itr1.next( ) ).
                       getValue( ) ) ).iterator( );
             while( itr2.hasNext( ) )
                  str += (Position)itr2.next( );
                  if( itr2.hasNext( ) )
                       str += ", ";
                  else
                       str += "\n";
         System.out.println( str );
     } // end of printMap
      // Cheap main
    public static void main( String [ ] args )
        WordSearch p = null;
        try
            p = new WordSearch( );
        catch( IOException e )
            System.out.println( "IO Error: " );
            e.printStackTrace( );
            return;
        System.out.println( "Solving..." );
        Map wordMap = p.solveBoggle( );
        p.printMap( wordMap );
    private int rows;
    private int columns;
    private char [ ][ ] theBoard;
    private Object [ ] theWords;
    private BufferedReader puzzleStream;
    private BufferedReader wordStream;
    private BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );
}Thanks