回溯 world search

1 回溯法

回溯法，主要应用在dfs中，主要思想是当你push一个元素后，记住要pop回去，大致的模板是

path.push_back(nums[i]);
dfs(pos+1);
path.pop();

还需要注意到一点是，有时候我们需要一个vis数组记录之前的元素有没有被使用过，常常和回溯一起使用，主要应用的场景是，当我们这次没有成功时，下一次需要从头开始寻找。在我们之前讲到的N皇后问题中，在每一行从的0-j列开始找，如果在这一列没有找到，则直接从下一行找，所以不需要vis数组记录。

if(vis[i]==1) continue; 
vis[i]==1;
path.push_back(nums[i]);
dfs(pos+1);
path.pop();
vis[i]==0;

详细的模板在我们之前用回溯法解决全排列问题有提到。

2 单词搜索

给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
dfs 标准模板
在矩阵中先找到这个单词的起始位置，再进行dfs(要用vis数组记录), 从上下左右四个方向去比较（需要回溯）

class Solution {
public:
    vector<vector<int>> vis;
    int m,n;
    vector<int> dx={1,-1,0,0};
    vector<int> dy={0,0,1,-1};
    bool dfs(int pos,int i, int j,vector<vector<char>>&  board,string word)
    {
        if(pos==word.size())
        return true;
        for(int d=0;d<4;d++)
        {
            int ii=i+dx[d];
            int jj=j+dy[d];
            if(ii<0||ii>=m||jj<0||jj>=n)
            continue;
            if(vis[ii][jj]==1||board[ii][jj]!=word[pos])
            continue;
            //if(board[ii][jj]==word[pos])
           // {
                vis[ii][jj]=1;
                if(dfs(pos+1,ii,jj,board,word))
                return true;
                 vis[ii][jj]=0;
           // }
        }
        return false;
    }
    bool exist(vector<vector<char>>& board, string word) {
         if(board.size()==0||board[0].size()==0)
         return false;
         m=board.size();
          n=board[0].size();
         vis.assign(m,vector<int>(n,0));
         for(int i=0;i<m;i++)
         {
             for(int j=0;j<n;j++)
             {  
                             
                 if(board[i][j]!=word[0])
                 continue;
                 if(board[i][j]==word[0])
                 {
                    vis[i][j]=1;
                     if(dfs(1,i,j,board,word)){
                     return true;}
                    vis[i][j]=0;
                 }
             }
         }
         return false;
    }
};