leetcode.934 最短的桥 - dfs+bfs综合应用

934. 最短的桥 

给你一个大小为 n x n 的二元矩阵 grid ，其中 1 表示陆地，0 表示水域。

岛 是由四面相连的 1 形成的一个最大组，即不会与非组内的任何其他 1 相连。grid 中 恰好存在两座岛 。

你可以将任意数量的 0 变为 1 ，以使两座岛连接起来，变成 一座岛 。

返回必须翻转的 0 的最小数目。

示例 1：

输入：grid = [[0,1],[1,0]]
输出：1

示例 2：

输入：grid = [[0,1,0],[0,0,0],[0,0,1]]
输出：2

示例 3：

输入：grid = [[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]]
输出：1

思路：

用dfs把第一个岛屿先标成2 

初始化dist数组全为-1

另一个岛屿的dist数组全为0

用bfs拓展另一个岛屿  一旦拓展到另一个岛屿返回dist[i][j];

最后结果-1

class Solution {
    int m,n;
    int[][] dist;//不能在这里初始化
    int[] dx=new int[]{-1,0,1,0},dy=new int[]{0,1,0,-1};

    public int shortestBridge(int[][] g) 
    {
        m=g.length;
        n=g[0].length;
        dist=new int[m][n];
        int f=1;
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                if(g[i][j]==f) //找第一个岛屿
                {
                    dfs(i,j,g);
                    f=-1;//防止记录另一个岛屿
                }
        return bfs(g)-1;
    }

    public void dfs(int x,int y,int[][] g)//java传递数组 方法修改数组 会直接修改数组的值
    {
        g[x][y]=2;
        for(int i=0;i<4;i++)
        {
            int a=dx[i]+x,b=dy[i]+y;
            if(a<0||a>=m||b<0||b>=n) continue;
            if(g[a][b]==2||g[a][b]==0) continue;
            dfs(a,b,g);
        }
    }

    public int bfs(int[][]g)
    {
        Queue<int[]> q=new LinkedList<>();
        for(int i=0;i<m;i++) 
            for(int j=0;j<n;j++) dist[i][j]=-1;

        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++) 
                if(g[i][j]==1) 
                {
                    q.offer(new int[] {i,j});
                    dist[i][j]=0;
                }
        while(!q.isEmpty())
        {
            int[] t=q.poll();
            int x=t[0],y=t[1];
            for(int i=0;i<4;i++)
            {
                int a=x+dx[i],b=y+dy[i];
                if(a<0||a>=m||b<0||b>=n) continue;
                if(dist[a][b]!=-1) continue;
                dist[a][b]=dist[x][y]+1;
                q.offer(new int[] {a,b});
                if(g[a][b]==2) return dist[a][b];
            }
        }
        return -1;
    }
}