Leetcode（79）——单词搜索

最新推荐文章于 2024-05-18 18:41:17 发布

SmileGuy17

最新推荐文章于 2024-05-18 18:41:17 发布

阅读量441

点赞数

分类专栏： Leetcode 文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/KCDCY/article/details/125681477

版权

Leetcode 专栏收录该内容

77 篇文章 6 订阅

订阅专栏

Leetcode（79）——单词搜索

题目

给定一个 $\times n$ 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

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

示例 1：

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
输出：true

示例 2：

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “SEE”
输出：true

示例 3：

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCB”
输出：false

提示：

m == board.length
n = board[i].length
1 <= m, n <= 6
1 <= word.length <= 15
board 和 word 仅由大小写英文字母组成

进阶：你可以使用搜索剪枝的技术来优化解决方案，使其在 board 更大的情况下可以更快解决问题？

题解

方法一：回溯法+剪枝优化

思路

设函数 $\text{check}(i, j, k)$ 表示判断以网格的 $(i, j)$ 位置出发，能否搜索到单词 $\textit{word}[k..]$ ，其中 $\textit{word}[k..]$ 表示字符串 $\textit{word}$ 从第 $k$ 个字符开始的后缀子串。如果能搜索到，则返回 $\texttt{true}$ ，反之返回 $\texttt{false}$ 。函数 $\text{check}(i, j, k)$ 的执行步骤如下：

如果 $\textit{board}[i][j] \neq s[k]$ ，当前字符不匹配，直接返回 $\texttt{false}$ 。
如果当前已经访问到字符串的末尾，且对应字符依然匹配，此时直接返回 $\texttt{true}$ 。
否则，遍历当前位置的所有相邻位置。如果从某个相邻位置出发，能够搜索到子串 $\textit{word}[k+1..]$ ，则返回 $\texttt{true}$ ，否则返回 $\texttt{false}$ 。

这样，我们对每一个位置 $(i, j)$ 都调用函数 $\text{check}(i, j, 0)$ 进行检查：只要有一处返回 $\texttt{true}$ ，就说明网格中能够找到相应的单词，否则说明不能找到。

为了防止重复遍历相同的位置，需要额外维护一个与 $\textit{board}$ 等大的 $\textit{visited}$ 数组，用于标识每个位置是否被访问过。每次遍历相邻位置时，需要跳过已经被访问的位置。

在这里插入图片描述
注意：

vector<int> Direction{-1, 0, 1, 0, -1};
for (int i = 0; i < 4; i++) {
	if(DFS(board, word, row + Direction[i], col + Direction[i+1], pos+1))
		return true;
}
board[row][col] = word[pos];
return false;

上面和下面相比，下面要更快，因为 vector 的 [] 并不是内置数组类型的运算符，而是重载运算符函数，会损失一部分时间

bool res= DFS(board,word,row+1,col,pos+1) || DFS(board,word,row-1,col,pos+1) || 
		DFS(board,word,row,col+1,pos+1) || DFS(board,word,row,col-1,pos+1);
board[row][col] = word[pos];
return res;

代码实现

Leetcode 官方题解：

class Solution {
public:
    bool check(vector<vector<char>>& board, vector<vector<int>>& visited, int i, int j, string& s, int k) {
        if (board[i][j] != s[k]) {
            return false;
        } else if (k == s.length() - 1) {
            return true;
        }
        visited[i][j] = true;
        vector<pair<int, int>> directions{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
        bool result = false;
        for (const auto& dir: directions) {
            int newi = i + dir.first, newj = j + dir.second;
            if (newi >= 0 && newi < board.size() && newj >= 0 && newj < board[0].size()) {
                if (!visited[newi][newj]) {
                    bool flag = check(board, visited, newi, newj, s, k + 1);
                    if (flag) {
                        result = true;
                        break;
                    }
                }
            }
        }
        visited[i][j] = false;
        return result;
    }

    bool exist(vector<vector<char>>& board, string word) {
        int h = board.size(), w = board[0].size();
        vector<vector<int>> visited(h, vector<int>(w));
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                bool flag = check(board, visited, i, j, word, 0);
                if (flag) {
                    return true;
                }
            }
        }
        return false;
    }
};

我自己的：

class Solution {
    vector<int> Direction{-1, 0, 1, 0, -1};
    int x, y;
    bool DFS(vector<vector<char>>& board, string& word, vector<vector<bool>>& visited, int row, int col, int nextword){
        if(nextword == word.size()) return true;
        int nextrow, nextcol;
        visited[row][col] = true;
        for(int i = 0; i < 4; i++){
            nextrow = row + Direction[i];
            nextcol = col + Direction[i+1];
            if(nextcol < 0 || nextcol >= x || nextrow < 0 || nextrow >= y)
                continue;
            if(visited[nextrow][nextcol] || word[nextword] != board[nextrow][nextcol])
                continue;
            if(DFS(board, word, visited, nextrow, nextcol, nextword+1))
                return true;
            else visited[nextrow][nextcol] = false;   // 回溯
        }
        return false;
    }

public:
    bool exist(vector<vector<char>>& board, string word) {
        x = board[0].size();
        y = board.size();
        vector<vector<bool>> visited;
        for(int n = 0; n < y; n++)
            visited.emplace_back(x, false);
        // 行row列col
        for(int row = 0; row < y; row++){
            for(int col = 0; col < x; col++){
                if(board[row][col] == word[0]){
                    if(DFS(board, word, visited, row, col, 1))
                        return true;
                    else visited[row][col] = false; // 回溯
                }
            }
        }
        return false;
    }
};

我自己的（改进后——取消辅助数组）：

class Solution {
    vector<int> Direction{-1, 0, 1, 0, -1};
    int row_L, col_L;
    bool DFS(vector<vector<char>>& board, string& word, int row, int col, int pos){
        if (col < 0 || col >= col_L || row < 0 || row >= row_L ||
            board[row][col] == '\0' || word[pos] != board[row][col])
            return false;
        if (pos == word.size()-1)
            return true;
        board[row][col] = '\0';
        for (int i = 0; i < 4; i++) {
            if(DFS(board, word, row + Direction[i], col + Direction[i+1], pos+1))
                return true;
        }
        board[row][col] = word[pos];    // 回溯
        return false;
    }

public:
    bool exist(vector<vector<char>>& board, string word) {
        col_L = board[0].size();
        row_L = board.size();
        // 行row列col
        for (int row = 0; row < row_L; row++) {
            for (int col = 0; col < col_L; col++) {
                if (DFS(board, word, row, col, 0))
                    return true;
            }
        }
        return false;
    }
};

我自己的（改进后——减少时间复杂度）：

class Solution {
    // vector<int> Direction{-1, 0, 1, 0, -1};
    int row_L, col_L;
    bool DFS(vector<vector<char>>& board, string& word, int row, int col, int pos){
        if (col < 0 || col >= col_L || row < 0 || row >= row_L ||
            board[row][col] == '\0' || word[pos] != board[row][col])
            return false;
        if (pos == word.size()-1)
            return true;
        board[row][col] = '\0';
        // for (int i = 0; i < 4; i++) {
        //     if(DFS(board, word, row + Direction[i], col + Direction[i+1], pos+1))
        //         return true;
        // }
        // 相比使用 vector 作为四方的选择，直接使用常数和当前坐标表示四个方位的 DFS 更节约时间
        bool res= DFS(board,word,row+1,col,pos+1) || DFS(board,word,row-1,col,pos+1) ||
        		DFS(board,word,row,col+1,pos+1) || DFS(board,word,row,col-1,pos+1);
        // if(DFS(board,word,row+1,col,pos+1)) return true;
        // if(DFS(board,word,row-1,col,pos+1)) return true;
        // if(DFS(board,word,row,col+1,pos+1)) return true;
        // if(DFS(board,word,row,col-1,pos+1)) return true;
        // if(DFS(board,word,row+Direction[2],col+Direction[1],pos+1)) return true;
        // if(DFS(board,word,row+Direction[0],col+Direction[1],pos+1)) return true;
        // if(DFS(board,word,row+Direction[1],col+Direction[2],pos+1)) return true;
        // if(DFS(board,word,row+Direction[1],col+Direction[0],pos+1)) return true;
        board[row][col] = word[pos];    // 回溯
        return res;
    }

public:
    bool exist(vector<vector<char>>& board, string word) {
        col_L = board[0].size();
        row_L = board.size();
        // 行row列col
        for (int row = 0; row < row_L; row++) {
            for (int col = 0; col < col_L; col++) {
                if (DFS(board, word, row, col, 0))
                    return true;
            }
        }
        return false;
    }
};

复杂度分析

时间复杂度：一个非常宽松的上界为 $\cdot 3^L)$ ，其中 $M, N$ 为网格的长度与宽度， $L$ 为字符串 $\textit{word}$ 的长度。在每次调用函数 $\text{check}$ 时，除了第一次可以进入 $4$ 个分支以外，其余时间我们最多会进入 $3$ 个分支（因为每个位置只能使用一次，所以走过来的分支没法走回去）。由于单词长为 $L$ ，故 $\text{check}(i, j, 0)$ 的时间复杂度为 $O(3^L)$ ，而我们要执行 $O (M N)$ 次检查。然而，由于剪枝的存在，我们在遇到不匹配或已访问的字符时会提前退出，终止递归流程。因此，实际的时间复杂度会远远小于 $\Theta(MN \cdot 3^L)$ 。
空间复杂度： $O (M N)$ 。我们额外开辟了 $O (M N)$ 的 $\textit{visited}$ 数组，同时栈的深度最大为 $O(\min(L, MN))$ 。