LG-DFS/BFS-P-1162

题目相关

由数字0组成的方阵中，有一任意形状闭合圈，闭合圈由数字1构成，围圈时只走上下左右4个方向。现要求把闭合圈内的所有空间都填写成2.例如：6×6的方阵（n=6），涂色前和涂色后的方阵如下：

0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1

0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1

输入格式
每组测试数据第一行一个整数(1≤n≤30)

接下来n行，由0和1组成的n×n的方阵。

方阵内只有一个闭合圈，圈内至少有一个0。

输出格式
已经填好数字2的完整方阵。

输入输出样例
输入
6
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1

输出
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1

说明/提示
1≤n≤30

题解相关

DFS.1

nb……orz

楼下dalao们的都看不懂，只好自己写了一个搜索的啦，用染色法，其实可以先练习拯救总部那道

HALF：因为大佬没写思路我就只能根据代码复述一遍思路了，大佬只说了上面一句话，下面所有步骤都是HALF自己理解的。

1. 第四五行，是dfs用来递归左右移动的，可以比喻为，步子。
   有另一种表达方法，如下：
   int stepArr[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
   //表示上下左右4个方向
   intx=node.x+stepArr[i][0];
   inty=node.y+stepArr[i][1];
2. 开32的数组，最外面一圈是为了防止越界多创造的一圈数组，无影响，只需要在循环时注意是从1开始计数即可。
3. dfs中的返回条件换句话说，超过边界的和之前非0的；这种条件就导致被围起来的那部分数字不会被改变
4. 输出时注意一下情况即可，结束。

BFS.1

这一题为什么是BFS呢,因为DFS的效率其实没有BFS那么高

思路:
1.我们假设所有的’0’其实都被包围,但事实上并不是
2.犯了错误就要纠正,具体有哪一些本来并不是被包围的’0’被我们误认成了被包围的?
3.我们发现,那些在矩阵边缘的其实都不应该被包围!(这个就自己证明吧)

程序实现:
1.先认为所有的’0’都应该被修改,并且真的把它修改成了’2’;
2.边角上的’2’其实本来不应该被修改的,那我们把他们改回去 ,改成’0’
3.然后来寻找与这些零相邻的’2’,它们其实也是被改错了的

代码

DFS.1

#include <bits/stdc++.h>
using namespace std;
int a[32][32],b[32][32];
int dx[5]={0,-1,1,0,0};
int dy[5]={0,0,0,-1,1};//第一个表示不动，是充数的，后面的四个分别是上下左右四个方向
int n,i,j;
void dfs(int p,int q){
    int i;
    if (p<0||p>n+1||q<0||q>n+1||a[p][q]!=0) return;//如果搜过头或者已经被搜过了或者本来就是墙的就往回
    a[p][q]=1;//染色
    for (i=1;i<=4;i++) dfs(p+dx[i],q+dy[i]);//向四个方向搜索
}
int main(){
    cin>>n;
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++){
            cin>>b[i][j];//其实不拿两个数组也可以，不过我喜欢啦
            if (b[i][j]==0) a[i][j]=0;
            else a[i][j]=2;
        }
    dfs(0,0);//搜索 从0，0开始搜
    for (i=1;i<=n;i++){
        for (j=1;j<=n;j++)
        if (a[i][j]==0) cout<<2<<' ';//如果染过色以后i，j那个地方还是0，说明没有搜到，就是周围有墙，当然就是被围住了，然后输出2
        else cout<<b[i][j]<<' ';//因为被染色了，本来没有被围住的水和墙都染成了1，所以就输出b[i][j]
        cout<<'\n';//换行
    }
}

DFS.2

//跟DFS.1基本一致，就是改成了用一个数组和部分改进
#include <iostream>
using namespace std;
int gr[32][32];//最外面一圈方便无条件进入dfs
int step[4][2]={{-1,0},{1,0},{0,-1},{0,1}};//表示上下左右
int num=0;//图大小，全局变量方便其他函数访问 
void MyDFS(int a, int b); 
int main()
{
	cin>>num;//图大小 
	for(int i=1;i<=num;++i){//输入图 
		for(int j=1;j<=num;++j){
			cin>>gr[i][j];
		}
	} 
	MyDFS(0,0);//将外围全部改为2 
	for(int i=1;i<=num;++i){//输出 
		for(int j=1;j<=num;++j){
			if(gr[i][j]==2) cout<<0<<" ";
			else if(gr[i][j]==0) cout<<2<<" ";
			else cout<<gr[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}
void MyDFS(int a, int b)
{
	int i;
	if(a<0||a>num+1||b<0||b>num+1||gr[a][b]!=0)
		return;//访问超出边界或者是围起来的墙或者是已经搜过了，返回
	gr[a][b]=2;//标记
	for(i=0;i<4;i++) MyDFS(a+step[i][0], b+step[i][1]);
	//往四个方向继续搜索标记 
}

BFS.1

#include<iostream>
#include<ctime>
#include<cstdio>
using namespace std;
int num[40][40],c;
int k;
int main()
{
 int i,j,k,l;
 cin>>c;
 for(i=1;i<=c;i++)for(j=1;j<=c;j++)
 {
 	scanf("%d",&num[i][j]);
 	if(num[i][j]==0)num[i][j]=2;
 }
 for(i=1;i<=39;i++)
 {num[0][i]=9;num[i][0]=9;}//这一行先不要管,先看懂整个程序
 //输入+预处理结束 
 for(i=1;i<=c;i++)
 {
 	if(num[1][i]==2){num[1][i]=0;}
 	if(num[i][1]==2)num[i][1]=0;
 	if(num[c][i]==2)num[c][i]=0;
 	if(num[i][c]==2)num[i][c]=0;//针对所有边角料来一遍 
 }
 for(k=1;k<=100;k++)//广度优先搜索 阈值=100 (事实上不需要那么多)
 //HALF：这个阈值的循环真没看懂……
 for(i=1;i<=c;i++)
 for(j=1;j<=c;j++)
 {
 	if(num[i][j]!=1)
 	if(num[i][j-1]==0||num[i-1][j]==0||num[i+1][j]==0||num[i][j+1]==0)
 	num[i][j]=0; 
 }
 for(i=1;i<=c;i++)
 {
 	
 	for(j=1;j<=c;j++)
 	printf("%d ",num[i][j]);
 	cout<<endl;
 }
 return 0;
}

BFS.2

//其实也是根据BFS.1改的，但是不知道为啥输出会多0
#include <iostream>
using namespace std;
int gr[32][32];//最外面一圈方便无条件进入dfs
int num=0;//图大小，全局变量方便其他函数访问 
int main()
{
	cin>>num;//图大小
	int i, j, k;//各种的循环计数 
	for(i=1;i<=num;++i){//输入图 
		for(j=1;j<=num;++j){
			cin>>gr[i][j];
			if(gr[i][j]==0) gr[i][j]=2;
		}
	} 
	for(i=1;i<32;i++)
		gr[0][i]=9;gr[i][0]=9;//预处理 
	for(i=1;i<=num;i++){//将所有的边界修改掉 
	 	if(gr[1][i]==2) gr[1][i]=0;//第一行 
	 	if(gr[i][1]==2) gr[i][1]=0;//第一列 
	 	if(gr[num][i]==2) gr[num][i]=0;//最后一行 
	 	if(gr[i][num]==2) gr[i][num]=0;//最后一列 
	}
	for(k=1;k<=100;k++){//广度优先搜索 阈值=100 (事实上不需要那么多)
	//这个真真不懂
		for(i=1;i<=num;i++){ 
			for(j=1;j<=num;j++){
				if(gr[i][j]!=1)//不是围的墙，即进不去围墙内侧 
				if(gr[i][j-1]==0||gr[i-1][j]==0||gr[i+1][j]==0||gr[i][j+1]==0)
				//如果身边有一个是0那就说明你是外侧的，因为外侧和边界是联通的 
				gr[i][j]=0; 
			}
		} 
	} 
	for(i=1;i<=num;++i){//输出 
		for(j=1;j<=num;++j){
			cout<<gr[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}