LeetCode·每日一题·934.最短的桥·DFS+BFS

最新推荐文章于 2022-10-25 15:52:32 发布

迅~

最新推荐文章于 2022-10-25 15:52:32 发布

阅读量390

点赞数 1

分类专栏： LeetCode刷题笔记文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/m0_64560763/article/details/127507778

版权

LeetCode刷题笔记专栏收录该内容

440 篇文章 4 订阅

订阅专栏

作者：小迅
链接：https://leetcode.cn/problems/shortest-bridge/solutions/1922514/dfsbfs-zhu-shi-chao-ji-xiang-xi-by-xun-g-s1jm/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

题目

示例

思路

题目要求我们找两个岛之间的最短距离，我们可以使用深度优先搜索找到第一个岛的位置，然后使用广度优先搜索找第一个岛和第二个岛之间的最短距离，当然这么说肯定过于片面。

具体实现：

对于使用深度优先搜索找到第一个岛的所有节点这个应该不难，和找岛屿的题目差不多，就是使用递归寻找当前岛的所有节点，并将第一个岛的所有元素都置为 2 ，防止后续影响对第二个岛的判断，在对第一个岛进行赋值时，我们需要保存第一个岛的所有临界海域，这些海域都有一个共同的特点，就是都只需要一步就可以到别的海域。

我们找到第一个岛并保存临界海域之后，就可以寻找第二个岛的位置，可以使用广度优先搜索，有点类似于二叉树的层次遍历。我们可以对之前保存的海域进行搜索，判断每一个海域是否可以连接到下一个岛屿，如果和第一个岛临界的所有海域中存在一个海域可以找到第二个岛，那么两个岛直接就是一个距离，在遍历过程中我们还需要保存当前海域临界的海域，用于下一次遍历寻找

代码

//用于保存海域位置
struct coordinate{
    int x;
    int y;
};
//dfs遍历第一个岛的所有节点
void dfs(int ** grid, int gridSize, int gridColSize, struct coordinate * path, int * index, int i, int j)
{
    if(i < 0 || j < 0 || i >= gridSize || j >= gridColSize || grid[i][j] == 2)
        return;
    if(grid[i][j] == 0)//保存临界海域
    {
        path[(*index)].x = i;
        path[(*index)++].y = j;
        return;
    }
    grid[i][j] = 2;//寻找其他节点
    dfs(grid, gridSize, gridColSize, path, index, i+1, j);
    dfs(grid, gridSize, gridColSize, path, index, i-1, j);
    dfs(grid, gridSize, gridColSize, path, index, i, j+1);
    dfs(grid, gridSize, gridColSize, path, index, i, j-1);
    return ;
}

int shortestBridge(int** grid, int gridSize, int* gridColSize){
    struct coordinate path[10000];
    bool hash[gridSize][gridColSize[0]];
    memset(hash, 0, sizeof(hash));
    int count = 1;
    int direct[][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    //寻找第一个岛
    for(int i = 0; i < gridSize; i++)
    {
        for(int j = 0; j < gridColSize[0]; ++j)
        {
            int index = 0;
            //广度优先寻找第一个岛边的海水
            if(grid[i][j] == 1)
            {
                dfs(grid, gridSize, gridColSize[0], path, &index, i, j);

                hash[i][j] = true;//优化寻找过程
                int left = 0;
                while(left < index)//其实和二叉树的层次遍历模板一样
                {
                    int right = index;
                    while(left < right)
                    {
                        for(int i = 0; i < 4; i++)//当前节点可以有四个发现，都用寻找
                        {
                            int xx = path[left].x + direct[i][0];
                            int yy = path[left].y + direct[i][1];
        
                            if(xx < 0 || yy < 0 || xx >= gridSize || yy >= gridColSize[0] || grid[xx][yy] == 2 || hash[xx][yy] == true)
                            {
                                //当前节点要么不存在，要么已经找过了
                                continue;
                            }
                            
                            hash[xx][yy] = true;
                            if(grid[xx][yy] == 1)
                            {
                                //找到了下一个岛屿结束
                                return count;
                            }
                            else//保存下一次的海域
                            {
                                path[index].x = xx;
                                path[index++].y = yy;
                            }
                            
                        }
                        left++;
                    }
                    count++;
                }
            }
        }
    }
    return 1;
}

作者：小迅
链接：https://leetcode.cn/problems/shortest-bridge/solutions/1922514/dfsbfs-zhu-shi-chao-ji-xiang-xi-by-xun-g-s1jm/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。


class Solution {
public:
struct coordinate{
    int x;
    int y;
};

void dfs(vector<vector<int>>& grid, int gridSize, int gridColSize, struct coordinate * path, int * index, int i, int j)
{
    if(i < 0 || j < 0 || i >= gridSize || j >= gridColSize || grid[i][j] == 2)
        return;
    if(grid[i][j] == 0)
    {
        path[(*index)].x = i;
        path[(*index)++].y = j;
        return;
    }
    grid[i][j] = 2;
    dfs(grid, gridSize, gridColSize, path, index, i+1, j);
    dfs(grid, gridSize, gridColSize, path, index, i-1, j);
    dfs(grid, gridSize, gridColSize, path, index, i, j+1);
    dfs(grid, gridSize, gridColSize, path, index, i, j-1);
    return ;
}

int shortestBridge(vector<vector<int>>& grid){
    struct coordinate path[10000];
    int gridSize = grid.size();
    int gridColSize = grid.size();
    bool hash[gridSize][gridColSize];
    memset(hash, 0, sizeof(hash));
    int count = 1;
    int direct[][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    //广度优先寻找第一个岛边的水
    for(int i = 0; i < gridSize; i++)
    {
        for(int j = 0; j < gridColSize; ++j)
        {
            int index = 0;
            if(grid[i][j] == 1)
            {
                dfs(grid, gridSize, gridColSize, path, &index, i, j);
                hash[i][j] = true;
                int left = 0;
                while(left < index)
                {
                    int right = index;
                    while(left < right)
                    {
                        for(int i = 0; i < 4; i++)
                        {
                            int xx = path[left].x + direct[i][0];
                            int yy = path[left].y + direct[i][1];
        
                            if(xx < 0 || yy < 0 || xx >= gridSize || yy >= gridColSize || grid[xx][yy] == 2 || hash[xx][yy] == true)
                            {
                                continue;
                            }
                            
                            hash[xx][yy] = true;
                            if(grid[xx][yy] == 1)
                            {
                                return count;
                            }
                            else
                            {
                                path[index].x = xx;
                                path[index++].y = yy;
                            }
                            
                        }
                        left++;
                    }
                    count++;
                }
            }
        }
    }
    return 1;
}
    
};

作者：小迅
链接：https://leetcode.cn/problems/shortest-bridge/solutions/1922514/dfsbfs-zhu-shi-chao-ji-xiang-xi-by-xun-g-s1jm/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。