1091 Acute Stroke (30 point(s))

最新推荐文章于 2024-11-05 17:24:38 发布

原创最新推荐文章于 2024-11-05 17:24:38 发布 · 257 阅读

0 ·

CC 4.0 BY-SA版权

PAT 专栏收录该内容

138 篇文章

订阅专栏

本文介绍了一种基于MRI图像分析的急性脑卒中核心体积计算方法，通过三维空间内的连通分支数计算，使用BFS算法实现了准确的体积测量。

1091 Acute Stroke (30 point(s))

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.

Figure 1

Output Specification:

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

Sample Input:

Sample Output:

考察BFS，实际上是要计算三维空间内的连通分支数。我先用DFS做，会因为递归太深出现段错误（25分）。然后用BFS完成并AC。

反思：DFS和BFS的比较。

DFS代码（25分）：

说明：实际上也没有必要同时设置a和visit两个数组，只要a即可。因为一个位置一旦遍历就不会再去遍历，遍历后直接将这个元素转为false即可。BFS代码简化了这一点。

#include<iostream>
using namespace std;
int a[1287][129][61];
bool visit[1287][129][61]={false};
int dir[6][3]={0,0,1,0,0,-1,0,1,0,0,-1,0,1,0,0,-1,0,0};
int M,N,L,T;
int cnt;
void dfs(int i,int j,int k){
	for(int t=0;t<6;t++){
		int ni = i+dir[t][0];
		int nj = j+dir[t][1];
		int nk = k+dir[t][2];
		if(ni>=0&&ni<M&&nj>=0&&nj<N&&nk>=0&&nk<L&&!visit[ni][nj][nk]&&a[ni][nj][nk]){
			visit[ni][nj][nk]=true;
			cnt++;
			dfs(ni,nj,nk);
		}
	}
}
int main(void){
	cin>>M>>N>>L>>T;
	for(int k=0;k<L;k++){
		for(int i=0;i<M;i++){
			for(int j=0;j<N;j++){
				cin>>a[i][j][k];
			}
		}
	} 
	int ans = 0;
	for(int k=0;k<L;k++){
		for(int i=0;i<M;i++){
			for(int j=0;j<N;j++){
				if(!visit[i][j][k]&&a[i][j][k]){
					visit[i][j][k]=true;
					cnt = 1;
					dfs(i,j,k);
					if(cnt>=T) ans+=cnt;
				}
			}
		}
	} 
	cout<<ans<<endl;
	return 0;
}

BFS代码（AC）：

对于每个起始位置的搜索，将这个位置结点首先加入队列，若有符合条件的邻接位置，继续加入，直到队列为空。注意每次加入时需要标记（将a[i][j][k]转为false）。

#include<iostream>
#include<queue> 
using namespace std;
bool m[1287][129][61]={false};
int dir[6][3]={0,0,1,0,0,-1,0,1,0,0,-1,0,1,0,0,-1,0,0};
int M,N,L,T;
struct Node{
	int x,y,z;
	Node(int nx,int ny,int nz):x(nx),y(ny),z(nz){}
};
int bfs(Node n){
	queue<Node> q;
	m[n.x][n.y][n.z] = false;
	q.push(n);
	int cnt = 1;
	while(!q.empty()){
		Node p = q.front();
		q.pop();
		for(int i=0;i<6;i++){
			int nx = p.x+dir[i][0];
			int ny = p.y+dir[i][1];
			int nz = p.z+dir[i][2];
			if(nx>=0&&nx<M&&ny>=0&&ny<N&&nz>=0&&nz<L&&m[nx][ny][nz]){
				cnt++;
				m[nx][ny][nz]=false;
				q.push(Node(nx,ny,nz));
			}
		}
	}
	return cnt;
}
int main(void){
	cin>>M>>N>>L>>T;
	int v;
	for(int k=0;k<L;k++){
		for(int i=0;i<M;i++){
			for(int j=0;j<N;j++){
				cin>>v;
				if(v==1) m[i][j][k]=true;
			}
		}
	} 
	int ans = 0;
	for(int k=0;k<L;k++){
		for(int i=0;i<M;i++){
			for(int j=0;j<N;j++){
				if(m[i][j][k]){
					int cnt = bfs(Node(i,j,k));
					if(cnt>=T) ans+=cnt;
				}
			}
		}
	} 
	cout<<ans<<endl;
	return 0;
}