LeetCode 79. 单词搜索

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

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

示例:

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

给定 word = "ABCCED", 返回 true.
给定 word = "SEE", 返回 true.
给定 word = "ABCB", 返回 false.
?     https://leetcode-cn.com/problems/word-search

第一次写的代码:没有进行回溯,代码就成了一次递归查找,找到就反回true了,否则就返回false,但是这样不回溯的写法明显是错的,只递归查找一次时,它查找的路径就是和上下左右四个方向的位移顺序一样了
(int dx[4] = {0,0,1,-1};int dy[4] = {1,-1,0,0};),上下左右四个方向的位移顺序本来应该是无特定顺序的,这明显是不对的.

class Solution {
public:
    bool flag = false;
    int visited[1000][1000];
    int height,width;
    void dfs(int y,int x,int index,string& word,vector<vector<char>>& board){
        if (index == word.size())
        {
            flag = true;
            return;
        }
        int dx[4] = {0,0,1,-1};
        int dy[4] = {1,-1,0,0};
        
        for (int i = 0 ; i < 4; ++i){
            int new_y = y + dy[i];
            int new_x = x + dx[i];
            if (0 <= new_y && new_y < height && 0 <= new_x && new_x < width && !visited[new_y][new_x] && board[new_y][new_x] == word[index]){
                visited[new_y][new_x] = 1;
                dfs(y + dy[i],x + dx[i],index + 1,word,board);
                visited[new_y][new_x] = 0;
                if(flag) return;  // 如果没有找到答案就回溯
            }
        }
        return;
    }
    
    
    bool exist(vector<vector<char>>& board, string word) {
        
        height = board.size();
        width = board[0].size();
        flag = false;
        memset(visited,0,sizeof visited);
        
        for (int i = 0; i < height ; ++i)
            for (int j = 0; j < width ; ++j){
                if (board[i][j] == word[0] && !visited[i][j]){
                    visited[i][j] = 1;
                    dfs(i,j,0 + 1,word,board);
                    visited[i][j] = 0;
                    if (flag) return true;
                }
            }
        return false;
    }
};