广度优先搜索之2个岛屿之间的最短距离

本文介绍了一种使用深度优先搜索(DFS)和队列实现的方法,解决连接两个岛屿的问题,通过双层循环和标记路径避免重复访问。核心是找到第一个岛屿后,逐步扩展到第二个岛屿,确保路径清晰且不包含已访问区域。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

感觉还是深度优先搜索啊,这里使用队列实现
注意事项,循环后的变量不要重复遍历。
思路:先找到第一个岛屿,然后用双循环遍历向第二个岛屿推进。这里用队列是方便消耗掉原先的数据,用栈就要用2个,一个是原先的栈,一个是新的栈。

#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <deque>

using namespace std;

vector<int> direction{-1, 0, 1, 0, -1};

void dfs(std::vector<std::vector<int>> &grid, deque<pair<int, int>> &island, int m, int n)
{
    deque<pair<int, int>> temp;

    temp.push_back(pair<int, int>(m, n));

    while (1)
    {
        if (temp.empty() == true)
        {
            std::cout << "finish loop" << std::endl;
            std::cout << "island size " << island.size() << std::endl;
            break;
        }

        pair<int, int> item = temp.front();

        int r = item.first;
        int l = item.second;

        std::cout << "r = " << r << " l = " << l << std::endl;

        grid[r][l] = 2;
        temp.pop_front();

        //std::cout << "temp size " << temp.size() << std::endl;

        island.push_back(item);

        for (int i = 0; i < 4; i++)
        {
            int r_ = r + direction[i];
            int l_ = l + direction[i + 1];

            if (r_ >= 0 && r_ < grid.size() && l_ >= 0 && l_ < grid[0].size())
            {
                if (grid[r_][l_] == 1)
                {
                    temp.push_back(pair<int, int>(r_, l_));
                    grid[r_][l_] = 2;
                    //island.push_back(pair<int, int>(r_, l_));
                }
            }
        }

        //std::cout << "emd" << std::endl;
    }

    return;
}

int minDistance(std::vector<std::vector<int>> &grid)
{
    //find one of island

    deque<pair<int, int>> points;
    int m, n;
    bool is_found = false;

    for (int i = 0; i < grid.size(); i++)
    {

        if (is_found == true)
        {
            std::cout << "m = " << m << " n = " << n << std::endl;
            break;
        }

        for (int j = 0; j < grid[0].size(); j++)
        {
            if (grid[i][j] == 1)
            {
                m = i;
                n = j;
                is_found = true;
                break;
            }
        }
    }

    deque<pair<int, int>> island;
    dfs(grid, island, m, n);

    std::cout << "island size " << island.size() << std::endl;

    int min_distance = 0;

    while (!island.empty())
    {
        int p_count = island.size();
        std::cout << "p_count " << p_count << std::endl;
        min_distance++;

        while (p_count--)
        {
            pair<int, int> item = island.front();
            island.pop_front();

            int r = item.first;
            int l = item.second;

            //std::cout << "r " << r << " l " << l << std::endl;

            for (int i = 0; i < 4; i++)
            {
                int r_ = r + direction[i];
                int l_ = l + direction[i + 1];

                if (r_ >= 0 && r_ < grid.size() && l_ >= 0 && l_ < grid[0].size())
                {
                    if (grid[r_][l_] == 1)
                    {
                        return min_distance - 1;
                    }
                    else if (grid[r_][l_] == 2)
                    {
                        continue;
                    }
                    else
                    {
                        //std::cout << "r_ " << r_ << " l_ " << l_ << std::endl;
                        island.push_back(pair<int, int>(r_, l_));
                        grid[r_][l_] = 2;
                    }
                }
            }
        }
    }

    return min_distance - 1;
}

int main(int, char **)
{
    std::cout << "Hello, world!\n";

    std::vector<std::vector<int>> grid = {{1, 1, 1, 1, 1, 1, 1},
                                          {1, 0, 0, 0, 0, 0, 1},
                                          {1, 0, 0, 0, 0, 0, 1},
                                          {1, 0, 0, 1, 0, 1, 1},
                                          {1, 0, 0, 0, 0, 0, 1},
                                          {1, 0, 0, 0, 0, 0, 1},
                                          {1, 1, 1, 1, 1, 1, 1}};

    std::cout << "min distance " << minDistance(grid) << std::endl;
}

### 回答1: 这道题目需要用到图论的知识。我们可以将每个岛看作一个节点,两个岛之间的桥看作一条边,构成一个无向图。然后我们可以使用广度优先搜索(BFS)来寻找两个岛之间的最短路径。 具体来说,我们可以从任意一个岛开始,使用BFS遍历整个图,记录每个节点到起始节点的距离。然后我们再从另一个岛开始,同样使用BFS遍历整个图,记录每个节点到另一个岛的距离。最后,我们可以枚举所有可能的桥的位置,计算两个岛之间的距离,取最小值即可。 需要注意的是,由于我们需要记录每个节点到两个岛的距离,因此需要使用两个二维数组来存储距离信息。同时,在BFS遍历时,需要使用一个队列来存储待访问的节点,以及一个二维数组来记录每个节点是否已经被访问过。 总的时间复杂度为O(n^4),空间复杂度为O(n^2)。 ### 回答2: 要计算连接两个岛的最短桥的长度,可以使用深度优先搜索算法来进行搜索。 首先,我们需要找到两个岛的位置,可以使用两层循环遍历整个布尔矩阵,找到第一个岛的起始位置和第二个岛的起始位置。 然后,从第一个岛的起始位置开始进行深度优先搜索,遍历与当前位置相连的所有水域(值为0的格子),并记录遍历过程中所经过的路径长度。在遍历的过程中,如果找到了第二个岛的位置,说明已经找到了连接两个岛的桥,并记录下此时的路径长度。 最后,将上述过程应用到两个岛的起始位置交换后进行一次,找到连接两个岛的最短桥的长度。 最后,将上述过程应用到两个岛的起始位置交换后进行一次,找到连接两个岛的最短桥的长度。遍历完所有可能的情况后,取得的最小路径长度即为连接两个岛的最短桥的长度。 总之,通过使用深度优先搜索算法来遍历布尔矩阵中的岛屿,记录路径长度,并通过找到连接两个岛的最短路径来计算桥的长度。 ### 回答3: 首先,我们可以遍历整个布尔矩阵,找到第一个岛的位置,并使用DFS或BFS算法将其所有相邻的陆地都标记为2。这样我们就能得到一个表示第一个岛的整数矩阵。 接下来,我们可以再次遍历整个布尔矩阵找到第二个岛的位置,并使用DFS或BFS算法将其所有相邻的陆地都标记为3。这样我们就能得到一个表示第二个岛的整数矩阵。 接下来,我们可以遍历整个布尔矩阵,找到第一个岛的边界位置,并记录下所有与边界相连的2的位置。然后,我们遍历这些边界位置并查找与之相邻的3的位置。这样就能找到连接两个岛的最短桥的长度。 具体的计算步骤如下: 1. 遍历整个布尔矩阵,找到第一个岛的位置,并使用DFS或BFS算法将其所有相邻的陆地都标记为22. 再次遍历整个布尔矩阵,找到第二个岛的位置,并使用DFS或BFS算法将其所有相邻的陆地都标记为3。 3. 遍历整个布尔矩阵,找到第一个岛的边界位置,并记录下所有与边界相连的2的位置。 4. 遍历这些边界位置,并查找与之相邻的3的位置。计算这些相邻位置与边界位置之间的距离,并记录最小距离。 5. 返回最小距离作为连接两个岛的最短桥的长度。 需要注意的是,以上算法假设只有两个岛存在,如果存在多个岛,则需要进行额外的处理。另外,如果两个岛之间不存在连接的路径,那么最短桥的长度就为无穷大。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

可峰科技

生活不易

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值