標題：全球變暖

你有一張某海域NxN畫素的照片，”.”表示海洋、”#”表示陸地，如下所示：

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

其中”上下左右”四個方向上連在一起的一片陸地組成一座島嶼。例如上圖就有2座島嶼。

由於全球變暖導致了海面上升，科學家預測未來幾十年，島嶼邊緣一個畫素的範圍會被海水淹沒。具體來說如果一塊陸地畫素與海洋相鄰(上下左右四個相鄰畫素中有海洋)，它就會被淹沒。

例如上圖中的海域未來會變成如下樣子：

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

請你計算：依照科學家的預測，照片中有多少島嶼會被完全淹沒。

【輸入格式】
第一行包含一個整數N。 (1 <= N <= 1000)
以下N行N列代表一張海域照片。

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

【輸出格式】
一個整數表示答案。

【輸入樣例】
7
…….
.##….
.##….
….##.
..####.
…###.
…….

【輸出樣例】
1

資源約定：
峰值記憶體消耗（含虛擬機器） < 256M
CPU消耗 < 1000ms

當時沒寫出來，後來看到別人的一點思路寫的，沒有測試資料，也不知道會不會超時什麼的

package 小島;

import java.util.*;

public
 
 class Main {
    public static String[] strArray = new String[1010];
    public static char[][] ca = new char[1010][1010];
    public static int n;
    public static int[] dx = { -1, 1, 0, 0 };
    public static int[] dy = { 0, 0, -1, 1 };
    public static int[][] overWhelm = new int[1010][1010];// 判斷該陸地是否會被淹沒，1表示會被淹沒，大於1的數表示剩下的小島
 

    public static int[][] v = new int[1010][1010];// 判斷該陸地是否已經搜尋過
    public static long num = 0;// 所有小島數

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        for (int i = 0; i < n; i++)
            strArray[i] = in.next();
        BFS();// 廣搜
        Set<Integer> set = new HashSet<>();// 存放的是未被淹沒的小島
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if (overWhelm[i][j] > 1)
                    set.add(overWhelm[i][j]);
        System.out.println(num - (long) set.size());
    }

    public static Queue<Node> que = new LinkedList<>();

    // 表示每一塊陸地
    static class Node {
        public int coordX;
        public int coordY;

        public Node(int x, int y) {
            coordX = x;
            coordY = y;
        }
    }

    public static void BFS() {
        for (int i = 0; i < n; i++) {
            ca[i] = strArray[i].toCharArray();
        }
        int d_num = 2;// 用來表示不同的小島
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (ca[i][j] == '#' && v[i][j] == 0) {
                    Node node = new Node(i, j);
                    que.add(node);
                    v[i][j] = 1;
                    while (!que.isEmpty()) {
                        Node tempNode = que.remove();
                        check(tempNode.coordX, tempNode.coordY, d_num);
                        for (int k = 0; k < 4; k++) {
                            int tempx = tempNode.coordX + dx[k];
                            int tempy = tempNode.coordY + dy[k];
                            if (tempx >= 0 && tempy >= 0 && tempx < n && tempy < n) {
                                if (ca[tempx][tempy] == '.') {// 上下左右存在海洋，會被淹沒
                                    continue;
                                }
                                if (ca[tempx][tempy] == '#' && v[tempx][tempy] == 0) {
                                    que.add(new Node(tempx, tempy));
                                    v[tempx][tempy] = 1;
                                }
                            }
                        }

                    }
                    num++;
                    d_num++;
                }
            }
        }
    }

    // 判斷上下左右是否有海洋
    public static void check(int tempx, int tempy, int d_num) {
        for (int k = 0; k < 4; k++) {
            int tax = tempx + dx[k];
            int tay = tempy + dy[k];
            // 邊界之外全是海洋
            if (tax < 0 || tay < 0 || tax >= n || tay >= n) {
                overWhelm[tempx][tempy] = 1;
                break;
            }
            if (ca[tax][tay] == '.') {
                overWhelm[tempx][tempy] = 1;
                break;
            }
            overWhelm[tempx][tempy] = d_num;
        }
    }
}