1091 Acute Stroke (连通图个数)

One important factor to identify acute stroke (急性脑卒中) is the volume of the stroke core. Given the results of image analysis in which the core regions are identified in each MRI slice, your job is to calculate the volume of the stroke core.

Input Specification:
Each input file contains one test case. For each case, the first line contains 4 positive integers: M, N, L and T, where M and N are the sizes of each slice (i.e. pixels of a slice are in an M×N matrix, and the maximum resolution is 1286 by 128); L (≤60) is the number of slices of a brain; and T is the integer threshold (i.e. if the volume of a connected core is less than T, then that core must not be counted).

Then L slices are given. Each slice is represented by an M×N matrix of 0’s and 1’s, where 1 represents a pixel of stroke, and 0 means normal. Since the thickness of a slice is a constant, we only have to count the number of 1’s to obtain the volume. However, there might be several separated core regions in a brain, and only those with their volumes no less than T are counted. Two pixels are connected and hence belong to the same region if they share a common side, as shown by Figure 1 where all the 6 red pixels are connected to the blue one.

Output Specification:
For each case, output in a line the total volume of the stroke core.

Sample Input:

3 4 5 2
1 1 1 1
1 1 1 1
1 1 1 1
0 0 1 1
0 0 1 1
0 0 1 1
1 0 1 1
0 1 0 0
0 0 0 0
1 0 1 1
0 0 0 0
0 0 0 0
0 0 0 1
0 0 0 1
1 0 0 0

Sample Output:

26

题意：
给定一个三维数组，0表示正常，1表示有肿瘤，肿瘤块的大小大于等于T才算作是肿瘤，计算所有肿瘤块中1的个数之和。
思路：
1.用一个judge函数判断当前位置是否需要访问，inq数组标记当前的点有没有被访问过。
2.三维的广度优先遍历，对每一个点广度优先累计肿瘤块中1的个数，如果大于等于阈值T就将结果累加起来。

注意：
1.使用深度优先遍历会爆栈。
2.01矩阵不可以设为int型，否则最后两个测试点会答案错误。

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

int n, m, l, T;
int matrix[1290][130][61];  //01矩阵
bool inq[1290][130][61] = {false};  //记录是否已经入过队
//增量矩阵
int X[6] = {0, 0, 0, 0, 1, -1};
int Y[6] = {0, 0, 1, -1, 0, 0};
int Z[6] = {1, -1, 0, 0, 0, 0};
struct node
{
    int x, y ,z;
}Node;

//判断坐标是否需要访问
bool judge(int x, int y, int z)
{
    if(x < 0 || x >= n || y < 0 || y >= m || z < 0 || z >= l)   //越界，返回false
        return false;
    if(matrix[x][y][z] == 0 || inq[x][y][z] ==true)     //当前位置为0或者已入过队，返回false
        return false;
    return true;    //以上都不满足，返回true
}

//BFS函数访问位置(x,y,z)所在的块，将该块中所有的1的inq设为true
int BFS(int x, int y, int z)
{
    int total = 0;  //计数当前块中1的个数
    queue<node> q;
    Node.x = x, Node.y = y, Node.z = z; //结点Node的位置为(x,y,z)
    q.push(Node);   //将Node入队
    inq[x][y][z] = true;    //位置(x,y,z)已经入过队
    while(!q.empty())
    {
        node top = q.front();   //取队首元素
        q.pop();    //队首元素出队
        total++;    //当前块中1的个数加1
        for(int i = 0; i < 6; i++)      //遍历队首元素(x,y,z)相邻的6个位置
        {
            int newX = top.x + X[i], newY = top.y + Y[i], newZ = top.z + Z[i];
            if(judge(newX, newY, newZ))     //如果新位置需要访问
            {
                Node.x = newX, Node.y = newY, Node.z = newZ;    //设置Node的坐标
                q.push(Node);   //将结点Node入队
                inq[newX][newY][newZ] = true;   //记录新位置已入过队
            }
        }
    }
    if(total >= T)  return total;   //如果1的个数大于等于阈值，则返回
    else    return 0;   //否则不记录块中1的个数
}

int main()
{
    scanf("%d%d%d%d", &n, &m, &l, &T);
    for(int z = 0; z < l; z++)      //输入矩阵
        for(int x = 0; x < n; x++)
            for(int y = 0; y < m; y++)
                scanf("%d", &matrix[x][y][z]);
    int ans = 0;        //计数
    for(int z = 0; z < l; z++)
        for(int x = 0; x < n; x++)
            for(int y = 0; y < m; y++)
                if(matrix[x][y][z] == 1 && inq[x][y][z] == false)   //当前位置是1且未入过队
                    ans += BFS(x, y, z);
    printf("%d\n", ans);
    return 0;
}