PAT日志 1091

顽强的小白

1091 Acute Stroke （30 分）

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

题目解析

听起来很高大上的题目，给出一个三维数组（起初没明白是个三维），寻找其中的块，输出这些块总共含有多少个1.
题目样例可以看到像是二维的实际上是把三维的形状切成一片一片，样例中，每三行是一片，剩下的自行脑补把。
用BFS，每到一个位置上就判断它的前后左右上下六个方位是否存在1（并且没有被访问过）如果存在就继续访问，并且在那个位置继续判断它的六个面，这样一直走下去，直到没有一个面需要访问。最后，因为这些块与块不一定相连，所以就使用遍历的手法，每一个可以走的位置都用一遍BFS。

代码实现

#include <cstdio> 
#include <algorithm> 
#include <queue> 
using namespace std; 
struct Node{  int x,y,z; }node; 

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}; 
int m,n,L,T;
int pixel[1290][130][61];
bool inq[1290][130][61];  //标记是否入过队 
bool judge(int x,int y,int z){
if(x>=n||x<0||y>=m||y<0||z>=L||z<0)
 return false;
else if(pixel[x][y][z]==0||inq[x][y][z]==true){
 return false;
}else
 return true;
}int  BFS(int x,int y,int z){
int tot=0;      //记录当前块中1的个数 
queue<Node> q;
node.x=x;node.y=y;node.z=z;
q.push(node);
inq[x][y][z]=true;
while(!q.empty()){
 Node top=q.front();
 q.pop();
 tot++;      //出队的时候计数 
 for(int i=0;i<6;++i){
  int newX=top.x+X[i];
  int newY=top.y+Y[i];
  int newZ=top.z+Z[i];
  if(judge(newX,newY,newZ)){
   node.x=newX;node.y=newY;node.z=newZ;
   q.push(node);
   inq[newX][newY][newZ]=true;
  }
 }
}
if(tot>=T) return tot;
else return 0;
}
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",&pixel[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(pixel[x][y][z]==1&&inq[x][y][z]==false){
    ans+=BFS(x,y,z);
   }
  }
 }
}
printf("%d\n",ans);
return 0;

}