16、单词搜索

最新推荐文章于 2022-09-03 11:59:57 发布

原创最新推荐文章于 2022-09-03 11:59:57 发布 · 146 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode中等专栏收录该内容

280 篇文章

订阅专栏

本文详细解析了在二维网格中查找单词的算法实现，利用回溯法遍历网格，匹配单词，确保同一单元格字母不被重复使用。文章提供了代码示例，包括初始化访问标记数组，递归检查单词匹配，并在回溯时恢复状态。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述：
给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
[‘A’,‘B’,‘C’,‘E’],
[‘S’,‘F’,‘C’,‘S’],
[‘A’,‘D’,‘E’,‘E’]
]

给定 word = “ABCCED”, 返回 true.
给定 word = “SEE”, 返回 true.
给定 word = “ABCB”, 返回 false.

很明显采用的是回溯的方法，但是需要注意的是：x+1 不能写成x++,对于y也是同样的道理，另外还需要注意的是：对于是否访问过需要有一个二维数组来进行判断，首先是初始化为零，然后每次访问过后设置为1，因为你是回溯法所以每次回溯完还需要回到初始化为零，这点需要特别注意的！！！
代码如下：

public boolean exist(char[][] board, String word) {
		int tem [][] =  new int[board.length][board[0].length];
		//首先找到第一个符合的然后进行回溯
		for (int i = 0; i < board.length; i++) {
			for (int j = 0; j < board[i].length; j++) {
				if(isget(i, j,board, 0, word,tem))
					return true;
			}
		}
		return false;
    }
	public boolean isget(int x,int y,char[][] word,int index,String words,int [][]tem){
		if(index == words.length()){
			return true;
		}
		if(x < 0 || x >= word.length || y < 0 || y >= word[x].length || word[x][y] != words.charAt(index)){
			return false;
		}
		if(tem[x][y] == 0){
			tem[x][y] = 1;
			if(isget(x+1, y, word, index+1, words,tem)||
					isget(x-1, y, word, index+1, words,tem)||
					isget(x, y+1, word, index+1, words,tem)||
					isget(x, y-1, word, index+1, words,tem))
				return true;
			tem[x][y] = 0;
		}
		return false;	
	}

基本是这个思路，很多细节需要把握
排名靠前的代码

class Solution {
     int m;
    int n;

    public boolean exist(char[][] board, String word) {
        if (null == board || word == null || word.isEmpty()) {
            return false;
        }

        boolean[][] used = new boolean[board.length][board[0].length];


        m = board.length;
        n = board[0].length;

        char[] charArray = word.toCharArray();

        for(int i=0; i<m; i++) {
            for(int j=0; j<n;j++) {
                if (exist(board, used, charArray, i, j, 0)) {
                    return true;
                }
            }
        }

        return false;

    }

    private boolean exist(char[][] board, boolean[][] mem, char[] charArray, int i, int j, int index) {
        if (index == charArray.length) {
            return true;
        }

        if (i >= m || i < 0) {
            return false;
        }

        if (j >= n || j < 0) {
            return false;
        }


        if (mem[i][j] || board[i][j] != charArray[index]) {
            return false;
        }

        mem[i][j] = true;
        // up -> right -> down -> left
        boolean found = exist(board, mem, charArray, i - 1, j, index + 1)
                || exist(board, mem, charArray, i, j + 1, index + 1)
                || exist(board, mem, charArray, i + 1, j, index + 1)
                || exist(board, mem, charArray, i, j - 1, index + 1);


        // recover
        if (!found) mem[i][j] = false;


        return found;
    }
}