Algorithm：矩阵中“块”的个数

问题描述：

• 给一个m * n的01矩阵，如果矩阵中若干个1是相邻的，那么称这些1是一个相邻的“块”。求给定矩阵中块的个数
• 输入样例（8 * 7的01矩阵）：
  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
  0 0 0 0 1 0 1
  1 0 1 1 0 1 0
• 该矩阵中“块”的个数就为：9

问题分析：

• 遍历整个矩阵，枚举每一个位置的元素，如果是0，就跳过；如果是1，就找其相邻4个位置的元素，判断是否为1，直到找完该“块”
• 为了防止走回头路，用一个同样大小的bool矩阵，来标记是否遍历过
• 当前位置为（x, y），则其相邻位置为：（x + 1, y）,（x - 1, y）,（x , y + 1）,（x, y - 1），可以用两个增量数组来实现对该位置的相邻元素进行遍历, 如: x[4] = {1, -1, 0, 0}，y[4] = {0, 0, 1, -1}

以下分别给出dfs和bfs实现方法

dfs:

#include <cstdio>
#include <queue>
using namespace std;

#define maxn 1000
#define ptf printf("\n");
#define here(a, b) printf("here here here (%d, %d)\n", a, b);

int n, m, num = 0;
int G[maxn][maxn] = {0}; //01矩阵
int x[4] = {0, 0, 1, -1}; //x，y的增量
int y[4] = {1, -1, 0, 0};
bool vis[maxn][maxn] = {false}; //bool矩阵，初始都未被访问为false

void dfs(int u, int v) //该元素的坐标
{
    here(u, v);
    vis[u][v] = true; //标记该元素，已被访问
    int newx, newy;
    for(int i = 0; i < 4; i++) //该位置的相邻的4个元素
    {
        newx = u + x[i];
        newy = v + y[i];
        if(newx < 0 || newx >= n || newy < 0 || newy >= m) continue; //越界的坐标，直接跳过
        if(vis[newx][newy] == false && G[newx][newy] == 1) //没有被访问且该元素值为1
        {
            dfs(newx, newy);
        }
    }
}
int main()
{
    //input
    //freopen("seekPart.txt", "r", stdin);
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++) //输入01矩阵
        for(int j = 0; j < m; j++)
            scanf("%d", &G[i][j]);

    //process
    for(int i = 0; i < n; i++) //对每个元素进行访问
    {
        for(int j = 0; j < m; j++)
        {
            if(vis[i][j] == false && G[i][j] == 1) //没有被访问且该元素值为1
            {
                dfs(i, j);
                ptf;
                num++; //记录连通块的个数
            }
        }
    }
    
    //output
//    for(int i = 0; i < n; i++) //打印邻接矩阵
//    {
//        for(int j = 0; j < m; j++)
//        {
//        printf("%d ", G[i][j]);
//        }
//        ptf;
//    }
    printf("连通字块个数：%d \n", num);
    return 0;
}

• 运行效果
  

bfs:

#include <cstdio>
#include <queue>
using namespace std;

#define maxn 1000
#define ptf printf("\n");
#define here(a, b) printf("here here here (%d, %d)\n", a, b);

struct node {
    int x, y;
    node(int xx, int yy) {
        x = xx;
        y = yy;
    }
};
int n, m, num = 0;
int G[maxn][maxn] = {0};
int x[4] = {0, 0, 1, -1};
int y[4] = {1, -1, 0, 0};
bool vis[maxn][maxn] = {false};

void bfs(int u, int v) 
{
    node temp = node(u, v);
    queue<node> q;
    q.push(temp);
    vis[u][v] = true;

    while(!q.empty())
    {
        node top = q.front();
        q.pop();
        here(top.x, top.y);
        int newx, newy;
        for(int i = 0; i < 4; i++)
        {
            newx = top.x + x[i];
            newy = top.y + y[i];
            if(newx < 0 || newx >= n || newy < 0 || newy >= m) continue; //瓒婄晫
            if(vis[newx][newy] == false && G[newx][newy] == 1)
            {
                temp.x = newx;
                temp.y = newy;
                vis[newx][newy] = true;
                q.push(temp);
            }
        }
    }
}
int main()
{
    //input
    //freopen("seekPart.txt", "r", stdin);
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            scanf("%d", &G[i][j]);

    //process
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            if(vis[i][j] == false && G[i][j] == 1)
            {
                bfs(i, j);
                ptf;
                num++;
            }
        }
    }
    
    //output
//    for(int i = 0; i < n; i++)  //打印邻接矩阵 
//    {
//        for(int j = 0; j < m; j++)
//        {
//        printf("%d ", G[i][j]);
//        }
//        ptf;
//    }
    printf("连通字块个数：%d \n", num);
    return 0;
}

• 运行结果：