数细胞-swust oj

数细胞(0964)

一矩形阵列由数字0到9组成，数字1到9代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。编程需要用到的队列及其相关函数已经实现，你只需要完成count函数以及主函数即可。 

第一行输入两个整数，分别代表矩阵的行和列 输入m*n的矩阵，由数字0到9组成。

4 10

1 2 3 4 5 1 1 1 6 7

1 0 3 4 5 6 1 5 1 0

2 0 4 5 6 6 1 6 7 1

0 0 6 0 6 6 1 0 8 9

细胞个数。

1

代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
int m, n;
int go[4][2] = { { -1, 0 }, { 1, 0 }, { 0, 1 }, { 0, -1 } };//定义方向数组：上下左右
int map[105][105];
void dfs(int x, int y)//遍历
{
    map[x][y] = 0;//之前把这里写成了map[x][y]='0';真是傻了，调了半天才调出来
    for (int i = 1; i <= 4; i++)//上下左右
    {//之前把这里写成了八个方向，所以怎么交都不对
    
            int gx = x + go[i-1][0];//左右
            int gy = y + go[i-1][1];//上下
            if (gx >= 0 && gx < m&&gy >= 0 && gy < n&&map[gx][gy] != 0)//在范围内，并且当前为细胞
            {
                dfs(gx, gy);//遍历某个区域
            }
    }
}
int main()
{

    int i, j, k=0;
    cin >> m >> n;
    {
        for (i = 0; i < m; i++)
        {
            for (j = 0; j < n; j++)
            {
                cin >> map[i][j];//输入地图
            }
        }
        for (i = 0; i < m; i++)
        {
            for (j = 0; j < n; j++)
                if (map[i][j] != 0)//初始
                {
                    k++;
                    dfs(i, j);//遍历
                }
        }
        cout << k ;
    }
    return 0;
}

这是第二种不同的写法，稍微麻烦了点：

#include<iostream>
using namespace std;
#define max 100
int m, n, str[max][max];
void Input()
{
    int i, j;
    cin >> m >> n;
    for (i = 0; i<m; i++)
    {
        for (j = 0; j<n; j++)
        {
            cin >> str[i][j];
        }
    }
}
bool exist(int x, int y)
{
    if (x >= 0 && x<m&&y >= 0 && y<n)
        return true;
    else
        return false;
}

void DFS(int x, int y)
{
    int tx, ty, i;
    str[x][y] = 0;
    for (i = 0; i<4; i++)
    {
        if (i == 0)
        {
            tx = x - 1;
            ty = y;
            if (exist(tx, ty))
            {
                if (str[tx][ty] != 0)
                {
                    DFS(tx, ty);
                }
            }
        }
        else
        if (i == 1)
        {
            tx = x + 1;
            ty = y;
            if (exist(tx, ty))
            {
                if (str[tx][ty] != 0)
                {
                    DFS(tx, ty);
                }
            }
        }
        else
        if (i == 2)
        {
            tx = x;
            ty = y + 1;
            if (exist(tx, ty))
            {
                if (str[tx][ty] != 0)
                {
                    DFS(tx, ty);
                }
            }
        }
        else
        if (i == 3)
        {
            tx = x;
            ty = y - 1;
            if (exist(tx, ty))
            {
                if (str[tx][ty] != 0)
                {
                    DFS(tx, ty);
                }
            }
        }
    }
}
int main()
{
    int i, j, count = 0;
    Input();
    for (i = 0; i<m; i++)
    {
        for (j = 0; j<n; j++)
        {
            if (str[i][j] != 0)
            {
                count++;
                DFS(i, j);
            }
        }
    }
    cout << count;
    return 0;
}

 DFS

#include<iostream>
using namespace std;
const int maxnum = 80 + 5;
int map[maxnum][maxnum];
int visit[maxnum][maxnum];//判断是否访问过
int dis[4][2] = { { -1, 0 }, { 1, 0 }, { 0, 1 }, { 0, -1 } };//方向数组
int M, N;
void DFS(int x,int y)
{
    int i;
    int dx, dy;
    for (i = 0; i < 4; i++)
    {
        dx = x + dis[i][0];
        dy = y + dis[i][1];
        if (dx < M&&dx >= 0 && dy < N&&dy >= 0 && visit[dx][dy]==0 )//判断是否越界  并且没访问过
        {
            visit[dx][dy] = 1;//节点已经访问
            DFS(dx,dy);//继续遍历
        }
    }


}
int main()
{
    int i,j;
    int cnt = 0;
    memset(map, 0, sizeof(map));
    memset(visit, 0, sizeof(visit));
    cin >> M >> N;
    for (i = 0; i < M;i++)
    for (j = 0; j < N; j++)
    {
        cin >> map[i][j];
    }
    for (i = 0; i < M; i++)
    {
        for (j = 0; j < N; j++)
        {
            if (map[i][j]!=0&& (visit[i][j]==0))
            {
                visit[i][j] = 1;
                DFS(i, j);
                cnt++;
            }
        }
    }
    cout << cnt << endl;
    
    return 0;
}