BFS和DFS算法

实例：机器人运动范围

一：BFS算法----队列实现

　　当图或树根节点满足条件就入队，若子节点满足条件，子节点入队，根节点出队，重复操作。

　　在机器人运动中，计算满足条件的数量，BFS算法只需考虑向右(x+!,y)或向下(x,y+1)

class Solution {//广度优先遍历
public:
   int movingCount(int m,int n,int k) {
//矩阵[m,n],visit标识节点是否已被访问
         std::vector<std::vector<bool> >  visit(m,std::vector<bool>(n,false));
         int c = 0;
         std::queue<std::pair<int,int> > que;
         std::pair<int,int> p = make_pair(0,0);
         que.push(p);
         visit[p.first,p.second] = true;
         bfs(m,n,k,c,visit,que);
         return c; 
    }     

private:
    int sum(int n) {
         int s = 0;
         while (n > 0) {
            s +=  n%10;
            n /= 10; 
         }
         return s; 
    }

    void bfs(int m,int n,int k,int&  count,std::vector<std::vector<bool> >& visit,std::queue<std::pair<int,int>& que) {
//节点p表示队列弹出的首节点，不断循环，直到找完所有适合的节点
           std::pair<int,int> p(0,0);
           while (!que.empty()) {
                   p = que.front();
                   que.pop();
                   count++;
                   if (p.first+1 >= 0 && p.first+1 < m && p.second >=0 && p.second < n   && sum(p.first+1)+sum(p.second) <= k && !visit[p.first+1][p.second]) {
                   que.push(p.first+1,p.second);
                  visit[p.first+1,p.second] = true;
                   }
                   if (p.first >= 0 && p.first < m && p.second+1 >=0 && p.second+1< n   && sum(p.first)+sum(p.second+1) <= k && !visit[p.first][p.second+1]) {
                   que.push(p.first,p.second+1);
                  visit[p.first,p.second+!] = true;
                   }
           }
     }
};

二：DFS算法---回溯算法

首先判断根节点，再判断其子节点，不断回溯，直到找完所有合适的点

class Solution {
public://深度优先
    int movingCount(int m,int n,int k){
         std::veector<vector<bool> >  visit(m,std::vector<bool>(n,false));
         int c = 0;
         dfs(m,n,k,0,0,c,visit);
         return c;
    }

private:

     int sum(int n) {
          int s = 0;
          while (n > 0) {
              s += n%10;
              n  /= 10;
          }
      return s;
     }

     void bfs(int m,int n,int i,int j,int& count,std::vector<std::vector<bool> >& visit {
          if (sum(i)+sum(j) <= k) {
                 count++;
                 visit[i][j] = true;
//首先向下深度搜索，直到遇到一个不符合条件的节点就返回上一个节点，并将该节点向右深度搜索。
                 if (i+1 >= 0 && i+1 < m && j >= 0 && j < n&& !visit[i][j])
                      dfs(m,n,i+1,j,count,visit);

                 if(i >= 0 && i < n && j+1 >= 0&& j+1 < n  && !visit[i][j])
                     dfs(m,n,i,j+!,count,visit);
          }
    }
};                            

 三：矩阵路径－－判断矩阵中是否含输入路径

class Solution {
public:
       bool exit(exit(vector<vector<char> >& board,string& word)
       {
              int m = board.size(),n = board[0].size();
              vector<vector<int>  vis(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]) {
                             if (dfs(board,vis,i,j,word,1))        return true;
                        }
                   }
              }
               return false;
       }

private:
      vector<vector<int> >  dir = {{0,1},{1,0},{0,-1},{-1,0}};
       bool  dfs(vector<vector<char> >& board,vector<vector<int> >& vis,int i,int j,string& word,int idx) {
              vis[i][j] = 1;
               if(idx == word.size())      return true;
               idx++;
               for(auto xy : dir) {
                    int  x = i+xy[0],y = j+xy[1];
                    if(x<0 ||  x >= board.size() || y < 0 || y >= board[0].size() || board[x][y]!=woed[idx] || vis[x][y])      continue;
                     else {
                           if(dfs(board,vis,x,y,word,idx)          return true;
                      }
               }
　　　　　　　　　　　　vis[i][j] = 0;
　　　　　　　　　　　　return false;

       }
};