【LeetCode79】【回溯】每日一题day14

这道题是前天的每日一题，我前天写了一整晚上，昨天时间不多都没有调过，还拉下了两天的题我尽量今天补上。

题面：给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

思路：遍历整个网格，找到单词开头的那个字母开始搜索，看这个字母的上下左右和单词的下一个字母一不一致，如果一致的话标记访问过再下去递归，如果递归后上下左右都找不到返回false就把访问过的标记去掉。

class Solution {
public:
    bool huiSu(vector<vector<char>> &board, vector<vector<bool>> &vis, int row, int col, string &word, int idx)
    {
        if (idx == word.size() - 1)
        {
            return true;
        }
        //调试
        // printf("\nreach to %d %d\n", row, col);

        // printf("idx = %d\n", idx);
        // for (int i = 0; i < board.size(); i++)
        // {
        //     for (int j = 0; j < board[i].size(); j++)
        //     {
        //         if (vis[i][j] == true) printf("0 ");
        //         else printf("1 ");
        //     }
        //     printf("\n");
        // }
        
        if (row - 1 >= 0 && board[row - 1][col] == word[idx + 1] && vis[row - 1][col] == false)
        {
            vis[row - 1][col] = true;
            if(huiSu(board, vis, row - 1, col, word, idx + 1) == true) 
            {
                return true;
            }
            else 
            {
                vis[row - 1][col] = false;
            }
        }
        
        if (row + 1 < board.size() && board[row + 1][col] == word[idx + 1] && vis[row + 1][col] == false)
        {
            vis[row +1][col] = true;
            if(huiSu(board, vis, row + 1, col, word, idx + 1) == true) 
            {
                return true;
            }
            else 
            {
                vis[row + 1][col] = false;
            }
        }
        

        if (col - 1 >= 0 && board[row][col - 1] == word[idx + 1] && vis[row][col - 1] == false)
        {
            vis[row][col - 1] = true;
            if(huiSu(board, vis, row, col - 1, word, idx + 1) == true) 
            {
                return true;
            }
            else 
            {
                vis[row][col - 1] = false;
            }
        }
        
        if (col + 1 < board[row].size() && board[row][col + 1] == word[idx + 1] && vis[row][col + 1] == false)
        {
            vis[row][col +1] = true;
            if(huiSu(board, vis, row, col + 1, word, idx + 1) == true) 
            {
                return true;
            }
            else 
            {
                vis[row][col +1] = false;
            }
        }
        return false;
    }

    bool exist(vector<vector<char>>& board, string word) {
        vector<vector<bool>>vis (board.size(), vector<bool>(board[0].size(), false));
        if (word.length() > board.size() * board[0].size())
        {
            return false;
        }
        bool ans = false;
        for (int i = 0; i < board.size(); i++)
        {
            for (int j = 0; j < board[i].size(); j++)
            {
                vis[i][j] = false;
                if (board[i][j] == word[0])
                {
                    vis[i][j] = true;
                    if (huiSu(board, vis, i, j, word, 0))
                    {
                        ans = true;
                        break;
                    }
                    else vis[i][j] = false;
                }
            }
        }
        return ans;
    }
};

上下左右写四遍太难调了，可以开一个数组directs = [(0, 1), (0, -1), (1, 0), (-1, 0)]用循环

中间遇到了heap buffer overflow内存错误，原来用到了Address Sanitizer检测工具，看了这篇文章觉得对于错误了解地更多了一点。

二维数组如果要传入函数的话要标明列的大小，如 bool[][200]
二维vector初始化 vector<vector<bool>>vis (board.size(), vector<bool>(board[0].size(), false));