LeetCode 934. Shortest Bridge

原题链接在这里：https://leetcode.com/problems/shortest-bridge/

题目：

In a given 2D binary array A, there are two islands.  (An island is a 4-directionally connected group of 1s not connected to any other 1s.)

Now, we may change 0s to 1s so as to connect the two islands together to form 1 island.

Return the smallest number of 0s that must be flipped.  (It is guaranteed that the answer is at least 1.)

Example 1:

Input: [[0,1],[1,0]]
Output: 1

Example 2:

Input: [[0,1,0],[0,0,0],[0,0,1]]
Output: 2

Example 3:

Input: [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
Output: 1

Note:

1. 1 <= A.length = A[0].length <= 100
2. A[i][j] == 0 or A[i][j] == 1

题解：

Find an index pointing to 1. Starting from it, iterating its neighbors and put all the islands into first set.

Perform BFS for each index in the current set, search surroundings, it is never visited before, and it is 1, then it is a cell in the other island, return level.

Otherwise, it is water, add it to nextSet.

Time Complexity: O(m*n). m = A.length. n = A[0].length.

Space: O(m*n).

AC Java:

 class Solution {
     int [][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
     public int shortestBridge(int[][] A) {
         if(A == null || A.length == 0 || A[0].length == 0){
             return -1;
         }

         int m = A.length;
         int n = A[0].length;
         int r = 0;
         int c = 0;
         for(int i = 0; i<m; i++){
             for(int j = 0; j<n; j++){
                 if(A[i][j] == 0){
                     continue;
                 }

                 r = i;
                 c = j;
             }
         }

         boolean [][] visited = new boolean[m][n];
         LinkedList<int []> que = new LinkedList<>();
         HashSet<int []> beginSet = new HashSet<>();
         visited[r][c] = true;
         que.add(new int[]{r,c});
         while(!que.isEmpty()){
             int [] cur = que.poll();
             beginSet.add(cur);
             for(int [] dir : dirs){
                 int x = cur[0] + dir[0];
                 int y = cur[1] + dir[1];
                 if(x<0 || x>=m || y<0 || y>=n || A[x][y]!= 1 || visited[x][y]){
                     continue;
                 }

                 visited[x][y] = true;
                 que.add(new int[]{x, y});
             }
         }

         int level = 0;

         while(!beginSet.isEmpty()){
             HashSet<int []> nextSet = new HashSet<>();
             for(int [] node : beginSet){
                 for(int [] dir : dirs){
                     int x = node[0] + dir[0];
                     int y = node[1] + dir[1];
                     if(x<0 || x>=m || y<0 || y>=n || visited[x][y]){
                         continue;
                     }

                     visited[x][y] = true;
                     if(A[x][y] == 1){
                         return level;
                     }

                     nextSet.add(new int[]{x, y});
                 }
             }

             level++;
             beginSet = nextSet;
         }

         return -1;
     }
 }