3

所以我一直在为游戏拼图编写一个程序。我创建了一个小板供用户使用,但问题是我不知道如何递归检查该单词是否在板上。我希望能够检查输入的单词是否确实在板上,并且有效。有效我的意思是,单词的字母必须彼此相邻。对于那些玩过boggle的人,你会明白我的意思。我要做的就是检查这个词是否在黑板上。

这就是我到目前为止所拥有的......

import java.io.*;
public class boggle {
    InputStreamReader isr = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);
    private String s = "";
    private int [][] lettersNum = new int [5][5];
    private char [][] letters = new char [5][5];
    private char [] word = new char [45]; // Size at 45, because the longest word in the dictionary is only 45 letters long 
    private char [] temp; 

    public void generateNum()
    {
        for (int row = 0; row < 5; row ++)
        {
            for (int col = 0; col < 5; col++)
            {
                lettersNum [row][col] = (int) (Math.random() * 26 + 65);
            }
        }
    }

    public void numToChar()
    {
        for (int row = 0; row < 5; row ++)
        {
            for (int col = 0; col < 5; col++)
            {
                letters [row][col] = (char)(lettersNum[row][col]);
            }
        }
    }

    public void display()
    {
        for (int row = 0; row < 5; row ++)
        {
            for (int col = 0; col < 5; col++)
            {
                System.out.print(letters[row][col]);
            }
            System.out.println("");
        }
    }

    public void getInput() throws IOException
    {
        System.out.println("Please enter a word : ");
        s=br.readLine();
        s=s.toUpperCase();
        word = s.toCharArray();
    }

    public int search(int row, int col)
    {
        if((row <0) || (row >= 5) || (col < 0) || (col >= 5))
        {
            return (0);
        }
        else
        {
            temp = word;
            return (1+ search(row +1, col) +
                    search(row -1, col) + 
                    search(row, col + 1) + 
                    search(row, col-1) +
                    search(row +1, col +1)+
                    search(row +1, col -1)+
                    search(row -1, col +1)+
                    search(row -1, col -1));
        }
    }


}

搜索是我的搜索算法,用于检查单词是否在板上,但我不知道它是否正确或是否有效。此外,我不知道如何实际告诉用户这个词是有效的!

感谢所有的帮助:)

所以我尝试使用您在下面建议的内容,但我不太了解 int [5][5] 的内容。所以这就是我尝试过的,但我不断出现越界错误!这里是源...

    public void locate()
{
    temp = word[0];
    for (int row = 0; row <5; row++)
    {
        for (int col = 0; col <5; col++)
        {
            if(temp == letters[row][col])
            {
                search(row,col);
            }
        }
    }
}

public int search(int row, int col)
{
    if(letters[row][col-1]==word[count]) // Checks the letter to the left
    {
        count++;
        letters[row][col-1] = '-'; // Just to make sure the program doesn't go back on itself
        return search(row, col-1);
    }
    else if (letters[row][col+1] == word[count])// Checks the letter to the right
    {
        count++;
        letters[row][col+1] = '-';// Just to make sure the program doesn't go back on itself
        return search(row, col +1);
    }
    else if (letters[row+1][col]== word[count])// Checks the letter below
    {
        count++;
        letters[row+1][col] = '-';// Just to make sure the program doesn't go back on itself
        return search(row +1 , col);
    }
    else if (letters[row-1][col]== word[count])// Checks the letter above 
    {
        count++;
        letters[row-1][col] = '-';// Just to make sure the program doesn't go back on itself
        return search(row -1 , col);
    }
    else if (letters[row-1][col-1]== word[count])// Checks the letter to the top left
    {
        count++;
        letters[row-1][col-1] = '-';// Just to make sure the program doesn't go back on itself
        return search(row -1 , col-1);
    }
    else if (letters[row-1][col+1]== word[count])// Checks the letter to the top right
    {
        count++;
        letters[row-1][col+1] = '-';// Just to make sure the program doesn't go back on itself
        return search(row -1 , col+1);
    }
    else if (letters[row+1][col-1]== word[count])// Checks the letter to the bottom left
    {
        count++;
        letters[row+1][col-1] = '-';// Just to make sure the program doesn't go back on itself
        return search(row +1 , col-1);
    }
    else if (letters[row+1][col+1]== word[count])// Checks the letter to the bottom right
    {
        count++;
        letters[row+1][col+1] = '-';// Just to make sure the program doesn't go back on itself
        return search(row +1 , col+1);
    }
    return 0;
}

私人int计数= 0;(在班级顶部声明,以防你想知道我从哪里得到[count]这个词

4

1 回答 1

3

您当前的搜索功能实际上并没有做任何事情。我假设这是家庭作业,所以没有免费的午餐;)

最简单的方法是有两个递归函数:

public boolean findStart(String word, int x, int y)

这将对棋盘进行线性搜索,以查找word. 如果您当前的位置不匹配,则使用下一组坐标调用自己。当它找到匹配项时,它会使用word、当前位置和一个新的空 4x4 矩阵调用您的第二个递归函数:

public boolean findWord(String word, int x, int y, int[][] visited)

此函数首先检查当前位置是否与 中的第一个字母匹配word。如果是这样,它将标记当前位置visited并循环遍历所有相邻的方块,除了那些visited通过调用自身word.substring(1)和那些坐标标记的方块。如果您用完 中的字母word,您已经找到它并返回 true。请注意,如果您返回 false,则需要从visited.

可以用一个函数来做到这一点,但通过拆分逻辑,我个人认为在你的头脑中更容易管理。一个缺点是它确实对单词中的每个第一个字母进行了额外的比较。要使用单个功能,您需要使用布尔值或深度计数器来跟踪您所处的“模式”。

编辑:您最长的单词应该只是16. Boggle 使用 4x4 棋盘,一个词不能使用同一位置两次。并不是说这真的很重要,但它可能对任务有用。另请注意,我只是在脑海中做到了这一点,并不知道我 100% 正确 - 评论表示赞赏。

根据评论进行编辑:

这是locate使用我上面概述的方法进行迭代的样子:

public boolean locate(String word) 
{ 
    for (int row = 0; row < 4; row++) 
    {  
        for (int col =0; col < 4; col++) 
        { 
            if (word.charAt(0) == letters[row][col])
            {
                boolean found = findWord(word, row, col, new boolean[4][4]);
                if (found) 
                    return true;
            } 
        } 
     }
     return false;
}    

同样的事情递归地看起来如下,这应该会有所帮助:

public boolean findStart(String word, int x, int y)
{
    boolean found = false;
    if (word.charAt(0) == letters[x][y])
    {
        found = findWord(word, x, y, new boolean[4][4]);
    } 

    if (found)
        return true;
    else 
    {
        y++;
        if (y > 3)
        {
            y = 0;
            x++;
        }

        if (x > 3)
           return false;    
    }

    return findStart(word, x, y);
}        

因此,这里findWord()有一个辅助方法getAdjoining()来向您展示这一切是如何工作的。请注意,我将visited数组更改为boolean只是因为它有意义:

public boolean findWord(String word, int x, int y, boolean[][] visited)
{
    if (letters[x][y] == word.charAt(0))
    {
        if (word.length() == 1) // this is the last character in the word
            return true;
        else
        {
            visited[x][y] = true;
            List<Point> adjoining = getAdjoining(x,y,visited);

            for (Point p : adjoining)
            {
                boolean found = findWord(word.substring(1), p.x, p.y, visited);
                if (found)
                    return true;
            }
            visited[x][y] = false;
        }

    }
    return false;
}

public List<Point> getAdjoining(int x, int y, boolean[][] visited)
{
    List<Point> adjoining = new LinkedList<Point>();

    for (int x2 = x-1; x2 <= x+1; x2++)
    {
        for (int y2 = y-1; y2 <= y+1; y2++)
        {
            if (x2 < 0 || x2 > 3 ||
                y2 < 0 || y2 > 3 ||
                (x2 == x && y2 == y) ||
                visited[x2][y2])
            {
                continue;
            }

            adjoining.add(new Point(x2,y2));

        }
    }

    return adjoining;
}

所以现在,在你从用户那里得到一个String(单词)的输入之后,你只需调用:

boolean isOnBoard = findStart(word,0,0);

我最初是在我的脑海中这样做的,然后沿着这条路走下去,试图向你展示它是如何工作的。如果我要真正实现这一点,我会做一些不同的事情(主要是消除单词中第一个字母的双重比较,可能通过将两者组合成一个方法,尽管你可以通过重新排列当前方法中的逻辑来做到这一点),但上面的代码确实有效,应该可以帮助您更好地理解递归搜索。

于 2011-04-23T16:21:52.493 回答