从 A1091 Acute Stroke 中看BFS

这道题是由一道基本的二维图中求“1”的块数转化来的，不同于原题是二维，四方向；这道题中将图（即矩阵）扩展为三维，六方向，然后求相连的“1”的块数，同时，题目中要求只有该块内1的数目大于等于T才能算作有效块。
Attention：
1.题目最后要求的不是块数，而是有效块内的1的数目。
2.BFS中记录数组inq记录的是当前位置是否入队而非是否已经访问过，区别在于若仅是是否访问过可能会造成该位置已在队列中但未访问导致的重复入队问题。
了解这些后，如果会BFS的话，这题就很简单了，基本就是模板题秒杀啦hhh
参考代码：

using namespace std;
#include<bits/stdc++.h>
struct node{
	int x,y,z;
}Node;

int n,m,l,t;
int matrix[60][1290][130];
bool inq[60][1290][130]={false};
int X[6]={0,0,0,0,1,-1};
int Y[6]={1,-1,0,0,0,0};
int Z[6]={0,0,1,-1,0,0};

bool judge(int x,int y,int z){
	if(x>=m || x<0 || y>=n ||y<0 ||z>=l ||z<0) return false;
	if(matrix[z][x][y] == 0 || inq[z][x][y] == true) return false;
	return true;
}

int BFS(int x,int y,int z){
	int ans=0;
	queue<node> Q;
	Node.x=x,Node.y=y,Node.z=z;
	Q.push(Node);
	inq[z][x][y]=true;
	ans++;
	while(!Q.empty())
	{
		node top=Q.front();
		Q.pop();
		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[newZ][newX][newY]=true;
				ans++;
			}
		}
	}
	return ans;
}

int main(){
	cin>>m>>n>>l>>t;
	for(int z=0;z<l;z++)
	{
		for(int x=0;x<m;x++)
		{
			for(int y=0;y<n;y++)
			{
				cin>>matrix[z][x][y];
			}
		}
	}
	int ans=0;
	for(int z=0;z<l;z++)
	{
		for(int x=0;x<m;x++)
		{
			for(int y=0;y<n;y++)
			{
				if(matrix[z][x][y] == 1 && inq[z][x][y] == false)
				{
					int tmp=BFS(x,y,z);
					if(tmp>=t) ans+=tmp;
				}
			}
		}
	}
	cout<<ans<<"\n";
	return 0;
} 

不同于上一篇《从 A1103 Integer Factorization 中看DFS》，BFS一般常用队列实现，而DFS常用递归实现。BFS（广度优先搜索）以层为单位，一层一层的搜索，只有当本层搜索完后才能搜索下一层，而DFS（深度优先搜索）是先走到头再返回。
基本写法如下：

模板：
	void BFS(int s){
		queue<int> q;
		q.push(s);
		while(!q.empty()){
			取出队首元素top;
			访问队首元素top;
			将队首元素出队;
			将top的下一层节点中未曾入队的节点全部入队，并设置标志位;
		}
	}