DFS+BFS-判断矩阵中块的个数

题目大意：求矩阵中块的个数

　　如6*7矩阵：

　　0 1 1 1 0 0 1

　　0 0 1 0 0 0 0

　　0 0 0 0 1 0 0

　　0 0 0 1 1 1 0

　　1 1 1 0 1 0 0

　　1 1 1 1 0 0 0

　　此矩阵中 块“1”的个数为4。

• 给出DFS做法

#include<bits/stdc++.h>
using namespace std;
int m,n;//m行n列
bool visit[20][20]=false;
int map_[20][20]={0};
void DFS(int x,int y){
    int next[4][2]={0,1,0,-1,1,0,-1,0};//四个方向
    for(int i=0;i<4;i++){
        int tx=x+next[i][0];
        int ty=y+next[i][1];
        if(visit[tx][ty]==true||tx<1||ty<1||tx>m||ty>n) continue;//剪枝
        if(visit[tx][ty]==false&&map_[tx][ty]==1){
            visit[tx][ty]=true;
            DFS(tx,ty);
        }
    }
}
int main(){
    while(cin>>m>>n){
        memset(visit,false,sizeof(visit));
        memset(map_,0,sizeof(map_));
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                cin>>map_[i][j];//初始化地图
            }
        }
        int cnt=0;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(visit[i][j]==false&&map_[i][j]==1){
                    //如果未被访问到 并且是能访问到的地方
                    cnt++;
                    DFS(i,j);
                }
            }
        }
        cout<<cnt<<endl;
    }
    return 0;
}

•  BFS-宽度优先搜索做法：值得注意的是 BFS中设置inqueue数组是判断节点是否已入过队，而不是节点 是否已被访问（visit）。因为如果设置成是否被访问，那么可能存在某个结点已在队列中 缺未被访问 则其他节点就可访问到此节点，就会导致很多节点反复入队，这样的效率显然不如设置成是否入过队高。

  #include<bits/stdc++.h>
  using namespace std;
  
  const int maxn=20;
  bool inqueue[maxn][maxn]={false};
  int m,n;
  int map_[maxn][maxn]={0};
  int next[4][2]={0,1,1,0,0,-1,-1,0};//4个方向
  struct Point{
    int x;
    int y;
    Point(int c,int d):x(c),y(d){}
  };
  
  void BFS(int x,int y){
      queue<Point>q ;
      q.push(Point(x,y));//将节点入队
      inqueue[x][y]=true;//标记已经入过队
      while(!q.empty()){
          Point top=q.front();
          q.pop();
          for(int i=0;i<4;i++){
              int tx=top.x+next[i][0];
              int ty=top.y+next[i][1];
              //如果超过边界；不能访问到；已经入队过 ---那么就跳过。
              if(tx<1||ty<1||tx>m||ty>n||map_[tx][ty]==0||inqueue[tx][ty]==true) continue;
              //否则---剩下的是合法的能访问到的
              inqueue[tx][ty]=true;//标记入队
              q.push(Point(tx,ty));
          }
      }
  }
  
  int main(){
      while(cin>>m>>n){
  
          memset(map_,0,sizeof(map_));
          memset(inqueue,false,sizeof(inqueue));
          for(int i=1;i<=m;i++){
              for(int j=1;j<=n;j++){
                  cin>>map_[i][j];//初始化地图
              }
          }
          int cnt=0;
          for(int i=1;i<=m;i++){
              for(int j=1;j<=n;j++){
                  if(inqueue[i][j]==false&&map_[i][j]==1){
                      //如果未被访问到 并且是能访问到的地方
                      cnt++;
                      BFS(i,j);
                  }
              }
          }
          cout<<cnt<<endl;
      }
      return 0;
  }

   ===================================================================================

• 2014北邮考研机试题目

• Problem C. 图像识别
  题目描述
  在图像识别中，我们经常需要分析特定图像中的一些特征，而其中很重要的一点就是识别出图像的多个区域。在这个问题中，我们将给定一幅N x M的图像，其中每个1 x 1的点都用一个[0,255]的值来表示他的RGB颜色。如果两个相邻的像素点颜色差不超过D，我们就认为这两个像素点属于同一个区域。对于一个像素点(x,y) ，以下这8个点（如果存在）是与它相邻的：（x-1, y-1），（x-1,y），（x-1,y+1），（x,y-1），（x,y+1），（x+1,y-1），（x+1,y），（x+1,y+1）。
  你的任务是写一个程序，分辨出给定图像中一共被分为多少个区域。
  输入格式
  输入数据包含多组测试数据。
  输入的第一行是一个整数T（T<=100），表示测试数据的组数。
  每组测试数据的第一行是三个整数N,M,D（1<=N,M<=100, 0<=D<=255），意义如上所述。
  接下来N行，每行M个整数，表示给定图像的每个像素点颜色。
  输出格式
  对于每组测试数据输出一行，即图像中的区域数量。
  输入样例
  2
  3 3 0
  1 1 1

  0 1 0

  0 1 0

  3 4 1

  10 11 12 13

  9 8 7 6

  2 3 4 5

  输出样例
  3

  1
• 能够看出 此题和上题大同小异，下面给出DFS做法~

  #include<bits/stdc++.h>
  using namespace std;
  const int maxn=105;
  int n,m,d;
  int map_[maxn][maxn]={0};
  bool visit[maxn][maxn]={false};
  int next[8][2]={-1,-1,-1,0,-1,1,0,-1,0,1,1,-1,1,0,1,1};
  void DFS(int x,int y){
      for(int i=0;i<8;i++){
          int tx=x+next[i][0];
          int ty=y+next[i][1];
          if(tx<0||ty<0||tx>n-1||ty>m-1||visit[tx][ty]==true) continue;
          if(visit[tx][ty]==false&&abs(map_[x][y]-map_[tx][ty])<=d){
              visit[tx][ty]=true;//找到同一区域其他点并标记。
              DFS(tx,ty);
          }
      }
  }
  int main(){
      int T;
      cin>>T;
      while(T--){
          memset(map_,0,sizeof(map_));
          memset(visit,false,sizeof(visit));
          cin>>n>>m>>d;
          for(int i=0;i<n;i++){
              for(int j=0;j<m;j++){
                  cin>>map_[i][j];
              }
          }//初始化地图
          int cnt=0;
          for(int i=0;i<n;i++){
              for(int j=0;j<m;j++){
                  if(visit[i][j]==false){
                      visit[i][j]=true;
                      DFS(i,j);//找到同一区域其他点并标记。
                      /*
                      for(int i=0;i<n;i++){
                          for(int j=0;j<m;j++){
                              cout<<visit[i][j]<<' ';
                          }
                          cout<<endl;
                      }
                      cout<<endl;
                      */
                      cnt++;//区域个数加1.
                  }
              }
          }
          cout<<cnt<<endl;
      }
      return 0;
  }