力扣 每日一题 934. 最短的桥难度：中等，rating: 1825（dfs / bfs）

Posted 2022-11-23 nefu-ljw

文章目录

• • 题目链接
  • 思路一（两次dfs）
  • 代码一
  • 思路二（一次dfs + 一次bfs）
  • 代码二

题目链接

https://leetcode.cn/problems/shortest-bridge/

题目来源于： 第109场周赛 Q3 rating: 1825

思路一（两次dfs）

题目要求的实际上是两个由1组成的连通块之间的最小距离。

那么直接可以想到：把这两个连通块内的所有点分别求出来，然后O(n²)遍历这些点，求它们的最小距离即为答案。

两次dfs（深度优先搜索）即可得到两个连通块内的所有点。

代码一

class Solution 
    vector<pair<int,int> > g[2]; // 分别存2个连通块内的所有点的坐标

    int dir[4][2]=0,1,0,-1,1,0,-1,0;

    bool vis[110][110];

    // 以(x,y)为起点，开始找值为1的连通块
    void dfs(int x,int y,vector<vector<int>>& grid,vector<pair<int,int> >& ans)
        int n=grid.size();
        vis[x][y]=1;
        ans.push_back(make_pair(x,y));
        for(int i=0;i<4;i++)
            int new_x=x+dir[i][0];
            int new_y=y+dir[i][1];
            if(new_x>=0&&new_x<n&&new_y>=0&&new_y<n&&grid[new_x][new_y]&&!vis[new_x][new_y])
                dfs(new_x,new_y,grid,ans);
            
        
    

public:
    int shortestBridge(vector<vector<int>>& grid) 
        memset(vis,0,sizeof(vis));
        int n=grid.size();
        int cnt=0; // 连通块的编号，cnt=0或1
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                if(grid[i][j]&&!vis[i][j])
                	// 题目条件“两个连通块”限制只会搜索两次
                    dfs(i,j,grid,g[cnt]);
                    cnt++;
                
            
        
        int mi=0x3f3f3f3f;
        for(int i=0;i<g[0].size();i++)
            for(int j=0;j<g[1].size();j++)
                auto [x1,y1]=g[0][i];
                auto [x2,y2]=g[1][j];
                int dis=abs(x1-x2)+abs(y1-y2)-1;
                assert(dis>0);
                mi=min(mi,dis);
            
        
        return mi;
    
;

思路二（一次dfs + 一次bfs）

一次dfs把第一个连通块内的所有点（值为1）加入到队列中，然后开始一次bfs（广度优先搜索），每次扩展一层值为0的点，直到扩展到值为1的点，说明遇到了第二个连通块，结束bfs。bfs扩展的步数即为答案。

代码二

class Solution 
    struct node
        int x,y,cnt;
    ;

    queue<node> q; // 用于bfs的队列

    int dir[4][2]=0,1,0,-1,1,0,-1,0;

    bool vis[110][110];

    // 以(x,y)为起点，开始找值为1的连通块
    void dfs(int x,int y,vector<vector<int>>& grid)
        int n=grid.size();
        vis[x][y]=1;
        q.push(x,y,0); // 第一个连通块的所有点加入队列，初始步数为0
        for(int i=0;i<4;i++)
            int new_x=x+dir[i][0];
            int new_y=y+dir[i][1];
            if(new_x>=0&&new_x<n&&new_y>=0&&new_y<n&&grid[new_x][new_y]&&!vis[new_x][new_y])
                dfs(new_x,new_y,grid);
            
        
    

public:
    int shortestBridge(vector<vector<int>>& grid) 
        memset(vis,0,sizeof(vis));
        int n=grid.size();
        bool flag=0;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                if(grid[i][j])
                	// 由flag限制只找一个连通块
                    dfs(i,j,grid);
                    flag=1; // 找到一个连通块了
                    break; // 结束第二层循环
                
            
            if(flag)
                break; // 结束第一层循环
            
        
        while(!q.empty())
            auto [x,y,cnt]=q.front();
            q.pop();
            for(int i=0;i<4;i++)
                int new_x=x+dir[i][0];
                int new_y=y+dir[i][1];
                if(new_x>=0&&new_x<n&&new_y>=0&&new_y<n&&!vis[new_x][new_y])
                    vis[new_x][new_y]=1;
                    if(!grid[new_x][new_y])
                        q.push(new_x,new_y,cnt+1);
                    else if(grid[new_x][new_y])
                        return cnt;
                    
                
            
          
        return -1;
    
;