934. 最短的桥

这里先用深度优先遍历，先找到第一座岛屿，将它们的邻接的海洋全部保存，然后从这些邻接海洋出发，利用广度优先遍历。直到遇到另外一座岛屿。

class Solution {
    int[][] A;
    Queue<List<Integer>> area = new LinkedList();    // 记录第一个岛的所有邻接点
    int[] dir = new int[]{0, 1, 0, -1, 0};

    public int shortestBridge(int[][] A) {
        this.A = A;
        boolean findLand = false;    // 标记是否找到第一个岛屿
        for(int i = 0; i < A.length; i++){
            if(findLand)
                break;
            for(int j = 0; j < A[0].length; j++){
                if(A[i][j] == 1){
                    dfs(i, j);
                    findLand = true;
                    break;
                }        
            }
        }
        int level = 0;
        int x, y;

        while(!area.isEmpty()){
            level++;
            int pointNum = area.size();
            while(pointNum != 0){
                pointNum--;
                List<Integer> head = area.poll();
                x = head.get(0);
                y = head.get(1);

                for(int i = 0; i < 4; i++){
                    int newX = x + dir[i];
                    int newY = y + dir[i + 1];
                    if(newX < 0 || newY < 0 || newX >= A.length || 
                    newY >= A[0].length || A[newX][newY] == 2)   
                        continue;
                    if(A[newX][newY] == 1)
                        return level;
                    else{
                        area.offer(Arrays.asList(newX, newY));
                        A[newX][newY] = 2;
                    } 
                }
            }
        }

        return level;
    }
    
    // 深度优先，寻找到岛屿所有点，将其值赋为2，并且将邻接点入区域集合
    private void dfs(int x, int y){
        if(x < 0 || y < 0 || x >= A.length || y >= A[0].length || A[x][y] == 2)
            return;
        if(A[x][y] == 0){
            area.offer(Arrays.asList(x, y));
            return;
        }
        A[x][y] = 2;
        dfs(x + 1, y);
        dfs(x - 1, y);
        dfs(x, y - 1);
        dfs(x, y + 1);
    }
}