BFS和DFS算法

Posted 2020-12-22 pengtangtang

实例：机器人运动范围

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

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

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

 1 class Solution {//广度优先遍历
 2 public:
 3    int movingCount(int m,int n,int k) {
 4 //矩阵[m,n],visit标识节点是否已被访问
 5          std::vector<std::vector<bool> >  visit(m,std::vector<bool>(n,false));
 6          int c = 0;
 7          std::queue<std::pair<int,int> > que;
 8          std::pair<int,int> p = make_pair(0,0);
 9          que.push(p);
10          visit[p.first,p.second] = true;
11          bfs(m,n,k,c,visit,que);
12          return c; 
13     }     
14 
15 private:
16     int sum(int n) {
17          int s = 0;
18          while (n > 0) {
19             s +=  n%10;
20             n /= 10; 
21          }
22          return s; 
23     }
24 
25     void bfs(int m,int n,int k,int&  count,std::vector<std::vector<bool> >& visit,std::queue<std::pair<int,int>& que) {
26 //节点p表示队列弹出的首节点，不断循环，直到找完所有适合的节点
27            std::pair<int,int> p(0,0);
28            while (!que.empty()) {
29                    p = que.front();
30                    que.pop();
31                    count++;
32                    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]) {
33                    que.push(p.first+1,p.second);
34                   visit[p.first+1,p.second] = true;
35                    }
36                    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]) {
37                    que.push(p.first,p.second+1);
38                   visit[p.first,p.second+!] = true;
39                    }
40            }
41      }
42 };

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

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

 1 class Solution {
 2 public://深度优先
 3     int movingCount(int m,int n,int k){
 4          std::veector<vector<bool> >  visit(m,std::vector<bool>(n,false));
 5          int c = 0;
 6          dfs(m,n,k,0,0,c,visit);
 7          return c;
 8     }
 9 
10 private:
11 
12      int sum(int n) {
13           int s = 0;
14           while (n > 0) {
15               s += n%10;
16               n  /= 10;
17           }
18       return s;
19      }
20 
21      void bfs(int m,int n,int i,int j,int& count,std::vector<std::vector<bool> >& visit {
22           if (sum(i)+sum(j) <= k) {
23                  count++;
24                  visit[i][j] = true;
25 //首先向下深度搜索，直到遇到一个不符合条件的节点就返回上一个节点，并将该节点向右深度搜索。
26                  if (i+1 >= 0 && i+1 < m && j >= 0 && j < n&& !visit[i][j])
27                       dfs(m,n,i+1,j,count,visit);
28 
29                  if(i >= 0 && i < n && j+1 >= 0&& j+1 < n  && !visit[i][j])
30                      dfs(m,n,i,j+!,count,visit);
31           }
32     }
33 };