单词搜索迷宫

package s1;
import  java.io.BufferedReader; 
import  java.io.*;
import  java.util.*;
   
//WordSearch  class   interface:solve   word   search   puzzle
//
//COnstruction:with  no  initializer
//*****************public  operations*******************
//int    sovePuzzle()    --->Print   all   words    found     in  the  puzzle  ;
//  return  number    of   matchers

public class WordSearch {
      public    WordSearch()   throws    IOException
      {
          /*WordSearch类的构造函数*/
        puzzleStream=openFile("Enter  puzzle  file");
        wordStream  =openFile("Enter   dictionary   name");
        System.out.println("Reading  files.....");
        readPuzzle();
        readWords();
      }
     
      public  int   solvePuzzlew()
      {
          //从所有起点开始，搜索所有方向的solvePuzzle程序
          /*routine   to   solve  the   word    serach   puzzle
           * Performs  checks  in   all   eight     directions
           * @ return  number  of   matchs          */
          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;
      }
          private  int   rows;
          private  int columns;
          private  char   theBoard[][];
          private  String  []   theWords;
          private  BufferedReader   puzzleStream;
          private  BufferedReader       wordStream;
          private  BufferedReader    in=new   BufferedReader  (new    InputStreamReader(System.in));
          private  static   int     prefixSearch(String []  a,  String  x)
          {
             int idx=Arrays.binarySearch(a, x);
             if(idx<0)
                 return  -idx-1;
             else 
                 return idx;
          }
          /*用于打开单词列表或者网格的openFile方法*/
          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  dictionary
              * Error  message   is  printed if    dictionary  is  not   sorted
              *  */  
           /*用于读取单词列表的readWords()方法*/
          
          private   void   readWords   ()  throws  IOException
    
          {
             List<String>words=new   ArrayList<String>();
             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=new   String[words.size()];
             theWords=words.toArray(theWords);
                     
          }
          
          //读取网格的readPuzzle方法
           /* Routine  to  read      the  grids
            * Check  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<String> puzzleLines=new  ArrayList<String>();
              
              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.out.println("Puzzle   is  not   rectangular;skipping   row");
                      }
                      else 
                      {
                          puzzleLines.add(oneLine);
                      }
                      rows=puzzleLines.size();
                      theBoard=new   char[rows][columns];
                      
                      int  r=0;
                      for(String  theLine:puzzleLines)
                      {
                          theBoard[r++]=theLine.toCharArray();
                          
                      }
                  }
                  
              }
              
          }
          private   int   solveDirection(int  baseRow,  int baseCol, int rowDelta ,int  colDelta)
          {
              /* 一个搜索的实现*/
              /* 
               * Search   the  grid   form   a  starting  point   and   direction
               * @return   number  of  matches*/
              
              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(!theWords[searchResult].startsWith(charSequence))
                      break;
                  if(theWords[searchResult].equals(charSequence))
                  {
                      numMatches++;
                      System.out.println("Found"+charSequence+"at"+baseRow+""+baseCol+"to"+i+""+j);
                  }
              }
              return  numMatches;
              
          }
          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.solvePuzzlew();
          }
         }