[LeetCode OJ] Word Search 深度优先搜索DFS

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

For example,
Given board =

[
  ["ABCE"],
  ["SFCS"],
  ["ADEE"]
]

word = "ABCCED", -> returns true,
word = "SEE", -> returns true,
word = "ABCB", -> returns false.

典型的搜索问题，这道题目用了两种方法来做。

一种用到动态规划的思想，用一个vector记录下word中前i个字符构成的子串的所有搜索路径，然后对于前i+1个字符构成的子串

查找搜索路径时，只需判断第i+1个字符在当前由前i个字符构成的子串的搜索路径的最后一个位置的上下左右四个方向是否出现，

如果出现则保存新的路径。最后只需判断查找word时是否有可行的搜索路径存在，如果有，则返回true，否则，返回false。但是，

这种方法的复杂度很高，对于大的测试数据，出现TLE。

 class Solution {
 public:
     bool exist(vector<vector<char> > &board, string word) {
         map<int, vector<vector<unsigned> > > path;  //path[i]表示word中的前i个字符构成的字符串在board中的查找路径，一共有path[i].size()条合法查找路径
         if(word.size()==)
             return true;
         int width = board[].size();
         for(unsigned i=; i<board.size()*width; i++)
         {
             if(board[i/width][i%width]==word[])
             {
                 vector<unsigned> start;
                 start.push_back(i);
                 path[].push_back(start);
             }
         }
         for(unsigned i=; i<word.size(); i++)
         {
             char c = word[i];
             //vector<vector<unsigned> > pt = path[i-1];

             for(vector<vector<unsigned> >::iterator it=path[i].begin(); it!=path[i].end(); it++)
             {
                 vector<unsigned> unipath = *it;

                 int lastpos = unipath.back();

                 if((lastpos-width)>= && board[(lastpos-width)/width][(lastpos-width)%width]==c && find(unipath.begin(), unipath.end(), (lastpos-width))==unipath.end())
                 {
                     unipath.push_back(lastpos-width);
                     path[i+].push_back(unipath);
                     unipath.pop_back();
                 }
                 if((lastpos+width)<(board.size()*width) && board[(lastpos+width)/width][(lastpos+width)%width]==c && find(unipath.begin(), unipath.end(), (lastpos+width))==unipath.end())
                 {
                     unipath.push_back(lastpos+width);
                     path[i+].push_back(unipath);
                     unipath.pop_back();
                 }
                 if(lastpos%width> && board[(lastpos-)/width][(lastpos-)%width]==c && find(unipath.begin(), unipath.end(), (lastpos-))==unipath.end())
                 {
                     unipath.push_back(lastpos-);
                     path[i+].push_back(unipath);
                     unipath.pop_back();
                 }
                 if((lastpos%width)<(width-) && board[(lastpos+)/width][(lastpos+)%width]==c && find(unipath.begin(), unipath.end(), (lastpos+))==unipath.end())
                 {
                     unipath.push_back(lastpos+);
                     path[i+].push_back(unipath);
                     unipath.pop_back();
                 }
                 if(i==word.size()- && path[word.size()].size()!=)
                     return true;
             }
         }
         if(path[word.size()].size()==)
             return false;
         else
             return true;
     }
 };

第二种是用到DFS（深度优先搜索），先找到可行的起始点，然后对于每个起始点判断是否有一条合法搜索路径存在，如果找到

一条合法搜索路径，则不进行后续搜索，直接返回true。如果所有可能的路径验证都不成立后，最后返回false。测试AC。

 void search(vector<vector<char> > &board, string word, vector<int> &path, bool &flag)
 {
     if(word.size()==)
     {
         flag = true;
         return;
     }

     int width = board[].size();
     char c = word[];
     if(path.size()==)
     {
         for(unsigned i=; i<board.size()*width; i++)
         {
             if(board[i/width][i%width]==c)
             {
                 path.push_back(i);
                 search(board, word.substr(), path, flag);
                 if(flag==true)
                     return;
                 path.pop_back();
             }
         }
     }
     else
     {
         int lastpos = path.back();
         if((lastpos-width)>= && board[(lastpos-width)/width][(lastpos-width)%width]==c && find(path.begin(), path.end(), (lastpos-width))==path.end())
         {
             path.push_back(lastpos-width);
             search(board, word.substr(), path, flag);
             if(flag==true)
                 return;
             path.pop_back();
         }
         if((lastpos+width)<(board.size()*width) && board[(lastpos+width)/width][(lastpos+width)%width]==c && find(path.begin(), path.end(), (lastpos+width))==path.end())
         {
             path.push_back(lastpos+width);
             search(board, word.substr(), path, flag);
             if(flag==true)
                 return;
             path.pop_back();
         }
         if(lastpos%width> && board[(lastpos-)/width][(lastpos-)%width]==c && find(path.begin(), path.end(), (lastpos-))==path.end())
         {
             path.push_back(lastpos-);
             search(board, word.substr(), path, flag);
             if(flag==true)
                 return;
             path.pop_back();
         }
         if((lastpos%width)<(width-) && board[(lastpos+)/width][(lastpos+)%width]==c && find(path.begin(), path.end(), (lastpos+))==path.end())
         {
             path.push_back(lastpos+);
             search(board, word.substr(), path, flag);
             if(flag==true)
                 return;
             path.pop_back();
         }

     }

 }

 class Solution {
 public:
     bool exist(vector<vector<char> > &board, string word) {
         bool flag = false;
         vector<int> path;

         search(board, word, path, flag);

         return flag;
     }
 };