第九届蓝桥杯JavaB组省赛-全球变暖

题目

你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：

…
.##…
.##…
…##.
…####.
…###.
…

其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。

由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。

例如上图中的海域未来会变成如下样子：

…
…
…
…
…#…
…
…

请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。

【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。

照片保证第1行、第1列、第N行、第N列的像素都是海洋。

【输出格式】
一个整数表示答案。

【输入样例】
7
…
.##…
.##…
…##.
…####.
…###.
…

【输出样例】
1

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

思路一：DFS+联通块

DFS的方法蓝桥杯官方的最后一个评测点过不去，因为栈溢出，也就是深度搜索的时候，栈溢出了。思路很简单，首先处理输入数据，用map和check记录，map数组中的值为true时，代表这个点为陆地，反之为海洋。然后check数组中的值为true代表着，这个陆地四面都是陆地，反之不是。
然后用就是深度搜索联通块，但是在搜索的时候，我们将记录这个岛里有没四面都是陆地的点，用flag记录。记得深度搜索的时候，将搜索过的点先将值改为false。再去遍历下一个点，不然就会导致来回的几个点重复遍历成为死循环。

public class test_01 {
		static boolean[][] map;
		static int[] b= {1,-1,0};
		static boolean[][] check;
		static boolean flag=false;
		public static void main(String args[]) {
			Scanner in=new Scanner(System.in);
			int N=in.nextInt();int ans=0;int coast=0;
			map=new boolean[N][N];
			check=new boolean[N][N];
			String t=null;
			char[] tt=new char[N];
			for(int i=0;i<N;i++)
			{
				t=in.next();
				tt=t.toCharArray();
				for(int j=0;j<N;j++)
					if(tt[j]=='#')
						map[i][j]=true;
			}
			for(int i=2;i<N-2;i++)
				for(int j=2;j<N-2;j++)
					if(is(i,j))
						check[i][j]=true;
			for(int i=1;i<N-1;i++)
				for(int j=1;j<N-1;j++)
				{
					if(map[i][j])
					{
						flag=false;
						dfs(i,j);
						if(flag)
							ans++;
						coast++;
					}
				}
					System.out.println(coast-ans);
		}
		private static void dfs(int i, int j) {
			if(check[i][j])
				flag=true;
			map[i][j]=false;
			if(map[i][j+1])
				dfs(i, j+1);
			if(map[i+1][j])
				dfs(i+1, j);
			if(map[i-1][j])
				dfs(i-1, j);
			if(map[i][j-1])
				dfs(i, j-1);
		}
		static boolean is(int i,int j)
		{
			if(map[i][j+1]&&map[i+1][j]&&map[i-1][j]&&map[i][j-1])
				return true;
			else 
				return false;
		}
}

思路二：BFS+联通块

不常用Queue，Queue初始化是Queue Q=new LinkedList();是用过链表实现的。BFS不会出现栈溢出，并且他会及时的将搜索过的点从队列里弹出，不想DFS会搜到底才释放空间。思路和上面的差不多。这个的评测就是100分。

public class test_01 {
		static boolean[][] map;
		static boolean[][] check;
		static boolean flag=false;
		static Queue<Node> Q=new LinkedList<>();
		public static void main(String args[]) {
			Scanner in=new Scanner(System.in);
			int N=in.nextInt();int ans=0;int coast=0;
			map=new boolean[N][N];
			check=new boolean[N][N];
			String t=null;
			char[] tt=new char[N];
			for(int i=0;i<N;i++)
			{
				t=in.next();
				tt=t.toCharArray();
				for(int j=0;j<N;j++)
					if(tt[j]=='#')
						map[i][j]=true;
			}
			for(int i=2;i<N-2;i++)
				for(int j=2;j<N-2;j++)
					if(is(i,j))
						check[i][j]=true;
			for(int i=1;i<N-1;i++)
				for(int j=1;j<N-1;j++)
				{
					if(map[i][j])
					{
						Q.clear();
						flag=false;
						insert(new Node(i,j));
						while(!Q.isEmpty())
							insert(Q.poll());
						if(flag)
							ans++;
						coast++;
					}
				}
					System.out.println(coast-ans);
			
		}
		private static void insert(Node node) {
			if(check[node.x][node.y])
				flag=true;
			if(map[node.x][node.y+1])
			{
				Q.add(new Node(node.x, node.y+1));map[node.x][node.y+1]=false;
			}
			if(map[node.x+1][node.y])
			{
				Q.add(new Node(node.x+1, node.y));
				map[node.x+1][node.y]=false;
			}
				
			if(map[node.x-1][node.y])
			{
				Q.add(new Node(node.x-1, node.y));
				map[node.x-1][node.y]=false;
			}
				
			if(map[node.x][node.y-1])
			{
				map[node.x][node.y-1]=false;
				Q.add(new Node(node.x, node.y-1));
			}
		}
		static boolean is(int i,int j)
		{
			if(map[i][j+1]&&map[i+1][j]&&map[i-1][j]&&map[i][j-1])
				return true;
			else 
				return false;
		}
		static class Node
		{
			int x;
			int y;
			public Node(int x, int y) {
				super();
				this.x = x;
				this.y = y;
			}
		}
}