Boggle游戲板搜索程序問題

Question

我正在編程一個笨拙的游戲板解算器。 它使用堆棧，從.dat / .txt文件讀取的用於游戲板的2D字母陣列數組，並搜索“狀態”以存儲其具體位置（到目前為止的點坐標，單詞）。 它旨在在板上搜索每個可能的字母組合以形成長度為3或更大的字符串，然后檢查字典文件以查看該單詞是否為有效的臨時單詞解決方案。 之后，它存儲單詞並返回參數中給出的游戲板解決方案列表。

我的問題：由於某種原因，該程序使我無法象以前從未寫過的一樣。 我對“狀態”的概念非常陌生，因此這可能是一個潛在的問題。 我相信我所擁有的已經相當接近工作了，我為此感到茫然。 當前的問題是它在檢查相鄰字母時從未存儲當前字母和構建字符串。 它確實會正確檢查鄰居，但不會構建任何字符串。 這是代碼：

BoggleSearch：包含main方法，充當驅動程序類。

import java.io.*;
import java.util.*;

public class BoggleSearch {

protected static int GRID_SIZE = 4;
public static String[][] grid = new String[GRID_SIZE][GRID_SIZE];

public static void main(String[] args) throws FileNotFoundException {

    if (args.length != 1) {
        System.err.println("Usage: java BoggleSearch gridFile");
        System.exit(1);

    }

    Scanner scan = new Scanner(new File(args[0]));

    String bigString = scan.next();
    bigString = bigString+scan.next();
    bigString = bigString+scan.next();
    bigString = bigString+scan.next();

    scan.close();

    int count = 0;

    for (int i = 0; i < GRID_SIZE; i++) {

        for (int j = 0; j < GRID_SIZE; j++) {


            grid[i][j] = bigString.substring(count, count);

            count++;
        }

    }

    WordSearch ws = new WordSearch(grid);

    ArrayList<BoggleSearchState> foundWords = ws.startSearch();

    System.out.println(foundWords);


   }

}

WordSearch：包含所有算法，這些算法可在給定游戲板上找到該字符串的所有可能字母組合，並與字典類進行交叉檢查。

import java.awt.Point;
import java.util.*;

public class WordSearch {

public static Stack<BoggleSearchState> stack;

public static ArrayList<BoggleSearchState> foundWords;

private String[][] grid;

private static final int GRID_SIZE = 4;

public BoggleDictionary dictionary;

public WordSearch(String[][] inputGrid) {

    grid = new String[GRID_SIZE][GRID_SIZE];
    stack = new Stack<BoggleSearchState>();
    foundWords = new ArrayList<BoggleSearchState>();
    inputGrid = new String[GRID_SIZE][GRID_SIZE];



    try {
        dictionary = new BoggleDictionary();
    } catch (Exception e) {
        System.err.println("blew up while making dict object");
        e.printStackTrace();
    }
}

public ArrayList<BoggleSearchState> startSearch() {

    for (int i = 0; i < grid.length; i++) {

        for (int j = 0; j < grid.length; j++) {

            BoggleSearchState b = new BoggleSearchState(
                    new ArrayList<Point>(), grid[i][j]);

            Point p = new Point(i, j);

            b.path.add(p);
            stack.push(b);


            while (!stack.isEmpty()) {

                BoggleSearchState s = stack.pop();

                if (s.getWord().length() >=1  && dictionary.contains(s.getWord())) {

                    foundWords.add(s);

                }

                Point loc = s.path.get(s.path.size() - 1);

                p = new Point(loc.x,loc.y);

                // Bottom Neighbor
                if (loc.x + 1 >= 0 && loc.x + 1 < grid.length && loc.y >= 0
                        && loc.y < grid.length) {
                    if (s.getVisited(new Point(p.x+1,p.y)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(new ArrayList<Point>(),s.getWord() + grid[loc.x + 1][loc.y]);
                        neo.path.add(new Point(p.x+1,p.y));
                        stack.push(neo);

                    }
                }

                // Top Neighbor
                if (loc.x - 1 >= 0 && loc.x - 1 < grid.length && loc.y >= 0
                        && loc.y < grid.length) {
                    if (s.getVisited(new Point(p.x-1,p.y)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() + 
                                grid[loc.x - 1][loc.y]);
                        neo.path.add(new Point(p.x-1,p.y));
                        stack.push(neo);

                    }
                }
                // Right Neighbor
                if (loc.x >= 0 && loc.x < grid.length && loc.y + 1 >= 0
                        && loc.y + 1 < grid.length) {
                    if (s.getVisited(new Point(p.x,p.y+1)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() + 
                                grid[loc.x][loc.y + 1]);
                        neo.path.add(new Point(p.x,p.y+1));
                        stack.push(neo);


                    }
                }
                // Left Neighbor
                if (loc.x >= 0 && loc.x < grid.length && loc.y - 1 >= 0
                        && loc.y - 1 < grid.length) {
                    if (s.getVisited(new Point(p.x,p.y-1)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() + 
                                grid[loc.x][loc.y - 1]);
                        neo.path.add(new Point(p.x,p.y-1));
                        stack.push(neo);

                    }
                }
                // Bottom-Right Neighbor
                if (loc.x + 1 >= 0 && loc.x + 1 < grid.length
                        && loc.y + 1 >= 0 && loc.y + 1 < grid.length) {
                    if (s.getVisited(new Point(p.x+1,p.y+1)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() + 
                                grid[loc.x + 1][loc.y + 1]);
                        neo.path.add(new Point(p.x+1,p.y+1));
                        stack.push(neo);

                    }
                }

                // Bottom-Left Neighbor
                if (loc.x + 1 >= 0 && loc.x + 1 < grid.length
                        && loc.y - 1 >= 0 && loc.y - 1 < grid.length) {
                    if (s.getVisited(new Point(p.x+1,p.y-1)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() +
                                grid[loc.x + 1][loc.y - 1]);
                        neo.path.add(new Point(p.x+1,p.y-1));
                        stack.push(neo);

                    }
                }

                // Top-Right Neighbor
                if (loc.x - 1 >= 0 && loc.x - 1 < grid.length
                        && loc.y + 1 >= 0 && loc.y + 1 < grid.length) {
                    if (s.getVisited(new Point(p.x-1,p.y+1)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() +
                                grid[loc.x - 1][loc.y + 1]);
                        neo.path.add(new Point(p.x-1,p.y+1));
                        stack.push(neo);

                    }
                }

                // Top-Left Neighbor
                if (loc.x - 1 >= 0 && loc.x - 1 < grid.length
                        && loc.y - 1 >= 0 && -1 < grid.length) {
                    if (s.getVisited(new Point(p.x-1,p.y-1)) != true) {

                        BoggleSearchState neo = new BoggleSearchState(
                                new ArrayList<Point>(),s.getWord() +
                                grid[loc.x - 1][loc.y - 1]);
                        neo.path.add(new Point(p.x-1,p.y-1));
                        stack.push(neo);

                    }
                }
            }
        }
    }
    return foundWords;
}
}

BoggleSearchState：創建一個狀態對象，用於存儲游戲板上字符串形成路徑的每個實例的必要數據。 包含為此目的所必需的方法。

import java.awt.Point;
import java.util.ArrayList;

public class BoggleSearchState {

private String word="";

public ArrayList<Point> path = new ArrayList<Point>();

public BoggleSearchState(ArrayList<Point>path, String word) {

    this.path = path;
    this.word = word;


}

  public String getWord() {


    return word;
}

public ArrayList<Point> getLocation() {


    return path;
}

public boolean getVisited (Point p) {

    ArrayList<Point> newPath = new ArrayList<Point>();
    for (Point s: path) {
        newPath.add(s);

        if (p.equals(s)) {
            return true;


        }

    }

    return false;
}

public String toString() {



    return this.word;
}

}

BoggleDictionary：為作業指定的編寫得很糟糕的字典類。 它已經過測試並且功能齊全。

//  BoggleDictionary.java

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.util.Scanner;
import java.util.HashSet;
import java.util.Iterator;

/** 
A class that stores a dictionary containing words that can be used in a
Boggle game.

@author Teresa Cole
@version CS221 Fall 2013
 */
    public class BoggleDictionary
    {
private HashSet<String> dictionary;

/** Create the BoggleDictionary from the file dictionary.dat
 */
@SuppressWarnings("unchecked")
public BoggleDictionary() throws Exception {
    ObjectInputStream dictFile = new ObjectInputStream(
            new FileInputStream( new File( "dictionary.dat")));
    dictionary = (HashSet<String>)dictFile.readObject();
    dictFile.close();
}

/** Check to see if a string is in the dictionary to determine whether it
 * is a valid word.
 * @param word the string to check for
 * @return true if word is in the dictionary, false otherwise.
 */
public boolean contains( String word)
{
    return dictionary.contains( word);
}

/** Get an iterator that returns all the words in the dictionary, one at a
 * time.
 * @return an iterator that can be used to get all the words in the
 * dictionary.
 */
public Iterator<String> iterator() 
{
    return dictionary.iterator();
}

/** 
 Main entry point
 */
static public void main(String[] args)  
{
    System.out.println( "BoggleDictionary Program ");

    Scanner kbd = new Scanner( System.in);
    BoggleDictionary theDictionary=null;
    try 
    {
        theDictionary = new BoggleDictionary();
    }
    catch (Exception ioe) 
    {
        System.err.println( "error reading dictionary");
        System.exit(1);
    }
    String word;

    /*
while (kbd.hasNext())
    {
    word = kbd.next();
    if (theDictionary.contains( word))
    System.out.println( word + " is in the dictionary");
    else
    System.out.println( word + " is not in the dictionary");
    }
     */

    Iterator<String> iter = theDictionary.iterator();
    while (iter.hasNext())
        System.out.println( iter.next()); 
}

}

我很樂意為此付出任何努力，因為我目前正為此努力。 我知道，有許多方法可以實現其他數據結構或組織方法，以在更有效的運行時中完成此任務。 但是，分配的關注點不是針對效率，而是使用這些數據結構（堆棧等）並了解如何能夠走錯方向，然后安全地回溯並在沒有程序的情況下走新方向的基本原則崩潰。 在此先感謝您，我會盡力回答所有問題。

Answer 1

據我所知，您在WordSearch有兩個網格，但是將它們都設置為初始化的數組。 您永遠不會使用看起來像內置在main方法中的網格。

但是很難說。

您給了我們很多數據，但信息卻很少。 我們不需要有關程序整體的詳細信息，甚至不需要這個大小的程序。 我們需要知道您的具體問題是什么。 沒有人願意為您調試此程序，實際上很少有人會像我所讀的一樣多。

解決初始化問題后，可調試程序，但可以找出它在何處執行（1）不應執行的操作，以及（2）您不了解的操作。 您需要花費足夠的時間來嘗試自己的＃1，以便進行調試方面的學習，這很可能使您可以解釋自己不了解的內容，並能很好地回答特定問題。 “這不是構建字符串”還遠遠不夠； 它不是在構建，在構建字符串是什么意思，等等。我期望這是因為它沒有輸入，但是我沒有做那么多的分析。