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

通过键盘，您将获得一个二维数组，作为字符串和单词。字眼 可以以任何方式（考虑所有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+")");

                        }
                    }
                }
            }

intx=0，y=0；
对于（intf=0；f我认为在开始编写代码之前，您需要更仔细地规划算法

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

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

（3） 每次我找到第二个字符作为第一个字符的邻居时，沿着数组中的字符进行迭代，沿着正确的方向移动，并对照单词检查每个字符

（4） 如果我匹配了整个单词，那么打印出匹配的位置并停止

（5） 如果我已经到达网格的边缘，或者发现一个不匹配的字符，那么继续循环（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;
                    }
                }
            }
        }
    }
}

注意：除0,0以外的所有单元格（您不希望重新访问同一单元格）。
代码的其余部分只是遍历字符矩阵，遍历您要查找的单词的整个长度，直到找到（或者可能找不到）完全匹配为止

这一次的问题是，如何打印word的第一个和最后一个
字母索引。我尝试了各种方法，比如在每个单词后打印
被搜查了，但都没用，我就要爆炸了

int[]值=新的int[2]；
对于（int i=0；i指

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

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=新的扫描仪（System.in）；
System.out.println（“大小：”）；
字符串s=k.nextLine（）；
s、 toUpperCase（）；
int Xindex=s.indexOf（'x'）；
intx=Integer.parseInt（s.substring（0，Xindex））；
int y=Integer.parseInt（s.substring（Xindex+1））；
System.out.println（“矩阵：”）；
字符[]矩阵=新字符[x][y]；
对于（int i=0；i
（所有8个邻域都要考虑
：再解释一下八个可能的方向：水平、垂直和对角XY（0,1）、XY（0，-1）、XY（1,0）、XY（-1,0）XY（1,1）、XY（1，-1）、XY（-1,1）、XY（-1，-1）你是说这是一个字母数组，就像一个单词搜索拼图？这是你的问题吗？没错，我需要一个递归。但问题是，我还不知道如何做递归。因此，我必须在没有递归的情况下编写代码。@JorgeCamposI按照你的建议编写了算法。但这次问题已经改变了。我不能再重复了能够打印第一个和最后一个字母的索引。好的，如果您想将新代码粘贴到问题中，我会看一看，看看是否能解决您的问题。不要替换旧代码（因为这会改变问题）；只需在末尾附加新代码。我在上面的回答中解决了您的问题。只需在代码末尾打印变量xStart、yStart、xEnd、yEnd。这是对应于单词开头和结尾索引的变量。请向我展示包括矩阵在内的整个代码。@ExceptionalException实际上，您的代码很有帮助很多，但我不能完全理解。在这里，我的代码，.程序按照您最初编写的方式工作。我编写了
blocksavaailable[][]
以了解该位置是否已被控制。另外
reversedWord
用于搜索单词的反面。我的意思是，程序必须搜索并找到ROAD和DAO
-1, -1
-1, 0
-1, 1
0, -1
0, 1
1, -1
1, 0
1, 1

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) {}

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)

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();