79. 单词搜索

给定一个 m x 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 更大的情况下可以更快解决问题？

思路：DFS 

进行深度优先搜索，函数参数有地图信息，是否访问过的矩阵，点坐标xy，还有word，最后是index，index代表word的索引，表示这层递归将要访问的点和word的index索引的点进行比较。

在定义一个path，存储搜过的路径（字母），终止条件为path大小是否和word大小相同，

里面具体搜索就是利用for循环4个方向，用当前传入的xy节点进行扩展，扩展的新节点如果没访问过并且这个点和word当前索引下的字母一样，则添加到路径，标记为访问过，进行dfs，同时进行回溯，在把路径点退出，点变成未访问过，这是由于如果dfs搜索失败了，没有找到匹配点，那么回溯之后，这条路径上往后失败的点全要恢复原样，不影响下次搜索。

然后是主函数，这里定义两个访问矩阵，一个是为回溯函数准备的，另一个为总体地图准备，总体地图访问时要判断当前点是否个word第一个字母相等，并且要判断这个点是否访问过，如果访问过，还进行搜索，会进入无限重复。

关键在于要使用两个visited，因为在进入dfs之后，它不应该管之前入口处是否访问过，如果依然使用一个visited，会导致少结果，dfs外面的visited是为了防止走到同一个入口处，和dfs里面的visited不要联系在一起。

class Solution {
public:
    int dir[4][2]={1,0,-1,0,0,1,0,-1};
    vector<char> path;
    bool flag=false;
    void dfs(vector<vector<char>>& board,int x,int y,vector<vector<bool>>& visited,string& word,int index)
    {
        
        if(path.size()==word.size())
        {
            flag=true;
            return;
        }
        for(int i=0;i<4;i++)
        {
            int newx=x+dir[i][0];
            int newy=y+dir[i][1];
            if(newx<0||newx>=board.size()||newy<0||newy>=board[0].size())
            {
                continue;
            }
            if(!visited[newx][newy]&&board[newx][newy]==word[index])
            {
                visited[newx][newy]=true;
                path.push_back(board[newx][newy]);
                dfs(board,newx,newy,visited,word,index+1);
                path.pop_back();
                visited[newx][newy]=false;;
            }
        }
        return;
    }
    bool exist(vector<vector<char>>& board, string word) {
        vector<vector<bool>> zongvisited(board.size(),vector<bool>(board[0].size(),false));
        vector<vector<bool>> visited(board.size(),vector<bool>(board[0].size(),false));
        for(int i=0;i<board.size();i++)
        {
            for(int j=0;j<board[0].size();j++)
            {
                if(board[i][j]==word[0]&&zongvisited[i][j]==false)
                {
                    path.push_back(board[i][j]);
                    zongvisited[i][j]=true;
                    visited[i][j]=true;
                    dfs(board,i,j,visited,word,1);
                    if(flag)
                    {
                        return true;
                    }
                    visited[i][j]=false;
                    path.clear();
                }
            }
        }
        return false;
    }
};