Question

您将获得一个2D数组作为字符串和一个单词通过键盘。这个单词可以以任何方式（所有8个邻居都被考虑）但你不能使用匹配时相同的字符两次。返回单词的第一个和最后一个字符的索引为（x，y）。如果未找到匹配，则返回-1。

这就是问题所在。我在搜索方面遇到了麻烦。我试过了：

int x=0,y=0;
            for(int f=0; f<WordinArray.length; f++){
                for(int i=0; i<matrix.length; i++){
                    for(int j=0; j<matrix[0].length; j++){
                        if(matrix[i][j].equals(WordinArray[f])){
                            x=i; y=j;
                            System.out.print("("+x+","+y+")");

                        }
                    }
                }
            }

但是，该代码没有按预期工作。我怎么能写这个搜索代码？

Answer 1

我认为在开始编写代码之前需要更仔细地规划算法。如果我这样做，我的算法可能看起来像这样。

（1）遍历数组，寻找单词的第一个字符。

（2）每次找到第一个字符时，请查看所有8个邻居，看看是否有第二个字符。

（3）每当我发现第二个字符作为第一个字符的邻居时，沿着数组中的字符进行迭代，向正确的方向移动，并根据单词检查每个字符。

（4）如果我匹配了整个单词，那么打印出我找到匹配的地方并停止。

（5）如果我到达了网格的边缘，或者发现了一个不匹配的字符，那么继续循环（2）的下一次迭代。

确定算法后，请考虑如何将每个步骤转换为代码。

Answer 2

如果我理解你的问题是对的。这是我现在快速回答的问题。

int H = matrix.length;
int W = matrix[0].length;
int xStart = -1, yStart = -1;
int xEnd = -1, yEnd = -1;

String word = "WordLookingFor".toLowerCase();

for (int i = 0; i < H; i++) {
    for (int j = 0; j < W; j++) {
        if (matrix[i][j] == word.charAt(0)) {
            int tempxStart = i;
            int tempyStart = j;
            for (int x = -1; x <= 1; x++) {
                for (int y = -1; y <= 1; y++) {
                    for (int k = 0; k < word.length(); k++) {
                        int xx = i+x*k;
                        int yy = j+y*k;
                        if(xx >= 0 && xx < H && yy >= 0 && yy < W && (x != 0 || y != 0)) {
                            if(matrix[xx][yy] != word.charAt(k))
                                break;
                            else if (matrix[xx][yy] == word.charAt(k) && k == word.length()-1) {
                                xStart = tempxStart;
                                yStart = tempyStart;
                                xEnd = xx;
                                yEnd = yy;
                            }
                        } else
                            break;
                    }
                }
            }
        }
    }
}

我用来检查所有8个邻居的一个小技巧是使用两个for循环来创建所有方向：

for (int x = -1; x <= 1; x++) {
    for (int y = -1; y <= 1; y++) {
        if(x !=0 || y != 0)
            System.out.println(x + ", " + y);
    }
}

这会创建

-1, -1
-1, 0
-1, 1
0, -1
0, 1
1, -1
1, 0
1, 1

注意：除了0,0之外的所有内容（您不想重新访问同一个单元格）。其余的代码只是遍历字符矩阵，虽然你要查找的单词的整个长度，直到找到（或者你没有找到）完全匹配。

Answer 3

参考Sixie's code

假设这是您程序的有效输入/输出？

Size:
4x4
Matrix:
a b c d
e f g h
i j k l
m n o p
Word: afkp
(0,0)(3,3)

我编辑了您的代码，因此它适用于此表单上的输入（此时它区分大小写，但可以通过设置.toLowerCase()

轻松更改

Scanner k = new Scanner(System.in);
System.out.println("Size: ");
String s = k.nextLine();
s.toUpperCase();

int Xindex = s.indexOf('x');
int x = Integer.parseInt(s.substring(0, Xindex));
int y = Integer.parseInt(s.substring(Xindex + 1));

System.out.println("Matrix:");
char[][] matrix = new char[x][y];

for (int i = 0; i < x; i++) {
    for (int p = 0; p < y; p++) {
        matrix[i][p] = k.next().charAt(0);
    }
}

System.out.print("Word: ");
String word = k.next();

int xStart = -1, yStart = -1;
int xEnd = -1, yEnd = -1;

// looping through the matrix
for (int i = 0; i < x; i++) {
    for (int j = 0; j < y; j++) {
        // when a match is found at the first character of the word
        if (matrix[i][j] == word.charAt(0)) {
            int tempxStart = i;
            int tempyStart = j;
            // calculating all the 8 normals in the x and y direction
            // (the 8 different directions from each cell)
            for (int normalX = -1; normalX <= 1; normalX++) {
                for (int normalY = -1; normalY <= 1; normalY++) {
                    // go in the given direction for the whole length of
                    // the word
                    for (int wordPosition = 0; wordPosition < word
                            .length(); wordPosition++) {
                        // calculate the new (x,y)-position in the
                        // matrix
                        int xPosition = i + normalX * wordPosition;
                        int yPosition = j + normalY * wordPosition;
                        // if the (x,y)-pos is inside the matrix and the
                        // (x,y)-vector normal is not (0,0) since we
                        // dont want to check the same cell over again
                        if (xPosition >= 0 && xPosition < x
                                && yPosition >= 0 && yPosition < y
                                && (normalX != 0 || normalY != 0)) {
                            // if the character in the word is not equal
                            // to the (x,y)-cell break out of the loop
                            if (matrix[xPosition][yPosition] != word
                                    .charAt(wordPosition))
                                break;
                            // if the last character in the word is
                            // equivalent to the (x,y)-cell we have
                            // found a full word-match.
                            else if (matrix[xPosition][yPosition] == word
                                    .charAt(wordPosition)
                                    && wordPosition == word.length() - 1) {
                                xStart = tempxStart;
                                yStart = tempyStart;
                                xEnd = xPosition;
                                yEnd = yPosition;
                            }
                        } else
                            break;
                    }
                }
            }
        }
    }
}
System.out.println("(" + xStart + "," + yStart + ")(" + xEnd + ","
        + yEnd + ")");
k.close();

Answer 4

这次问题是我怎么能打印出第一个和最后一个字字母的索引。我尝试了各种方法，比如在每个单词后打印被搜查了。但是，所有这些都没有奏效。我快要爆炸了。

int[] values = new int[2];
                for(int i=0; i<matrix.length; i++){
                    for(int j=0; j<matrix[0].length; j++){

                        if(Character.toString(word.charAt(0)).equals(matrix[i][j]) == true || Character.toString(ReversedWord.charAt(0)).equals(matrix[i][j]) == true ){
                            System.out.print("("+ i + "," +j+")");
                            //First letter is found.Continue.
                        for(int p=1; p<word.length(); p++){

                        try{
                            for (int S = -1; S <= 1; S++) {
                                for (int SS = -1; SS <= 1; SS++) {
                                    if(S !=0 || SS != 0)
                                        if(matrix[i+S][j+SS].equals(Character.toString(word.charAt(p))) && blocksAvailable[i+S][j+SS] == true || 
                                            matrix[i+S][j+SS].equals(Character.toString(ReversedWord.charAt(p))) && blocksAvailable[i+S][j+SS] == true) {
                                                values[0] = i+S;
                                                values[1] = j+SS;
                                                blocksAvailable[i+S][j+SS] = false;


                                        }
                                }
                            }
                        }catch (ArrayIndexOutOfBoundsException e) {}

搜索给定字符串数组中的单词

4 个答案: