【4.5】图搜索算法-BFS和DFS求岛屿的最大面积

一、题目

        给定一个包含了一些 0 和 1 的非空二维数组 grid 。一个岛屿是由一些相邻的 1 (代表土地)构成的组合， 这里的「相邻」要求两个1必须在水 平或者竖直方向上相邻 。你可以假设 grid 的四个边缘都被0（代表水）包围着。 找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

[ [ 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 0 ] ,

[ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 0 , 0 , 0 ] ,

[ 0 , 1 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] ,

[ 0 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 0 , 1 , 0 , 0 ] ,

[ 0 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 1 , 1 , 0 , 0 ] ,

[ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 0 , 0 ] ,

[ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 0 , 0 , 0 ] ,

[ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 0 , 0 , 0 ] ]

对 于 上 面 这 个 给 定 矩 阵 应 返 回 6 。 注 意 答 案 不 应 该 是 11 ， 因 为 岛 屿 只 能 包 含 水 平 或 垂 直 的四个方向的 1 。

示例 2:

[ [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] ]

对于上面这个给定的矩阵, 返回 0 。

注意: 给定的矩阵 grid 的长度和宽度都不超过 50。

二、解题思路

DFS思路：

        这道题目无论使用深度优先搜索（DFS）还是广度优先搜索（BFS）都可以很好地解决。DFS的策略是沿着一个方向不断深入探索，直到不满足条件为止（例如走出网格的边界，或者当前位置的值为0）。就像下面

BFS思路：

        BFS可以通过使用一个队列来实现。其实现原理是：如果一个位置的值为1，我们就将其上下左右四个方向上值为1的点的坐标全部加入队列中，然后将当前位置的值改为0，以防止重复计算。接着，从队列中逐个取出元素，并重复上述操作，直到队列为空为止。例如，当遍历到红色的1时，我们会将其上下左右四个方向上值为1的位置坐标全部加入队列中。

三、代码实现

DFS实现方式：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int dfs(vector<vector<int>>& grid, int i, int j) {
    // 边界条件的判断
    if (i >= 0 && i < grid.size() && j >= 0 && j < grid[0].size() && grid[i][j] == 1) {
        // 当前位置如果是1，为了防止重复计算就把他置为0，然后再从他的上下左右四个方向开始查找
        grid[i][j] = 0;
        return 1 + dfs(grid, i + 1, j) + dfs(grid, i - 1, j) + dfs(grid, i, j - 1) + dfs(grid, i, j + 1);
    }
    return 0;
}

int maxAreaOfIsland(vector<vector<int>>& grid) {
    int maxArea = 0;
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[0].size(); j++) {
            if (grid[i][j] == 1) { // 如果当前位置是1，开始计算
                maxArea = max(maxArea, dfs(grid, i, j));
            }
        }
    }
    return maxArea;
}

int main() {
    // 示例网格
    vector<vector<int>> grid = {
        {0, 1, 0, 0, 1},
        {1, 1, 0, 0, 0},
        {0, 0, 1, 1, 0},
        {0, 0, 0, 1, 1}
    };

    int result = maxAreaOfIsland(grid);
    cout << "最大岛屿面积: " << result << endl;

    return 0;
}

BFS实现方式：

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

int bfs(vector<vector<int>>& grid, int i, int j) {
    int m = grid.size(), n = grid[0].size();
    if (grid[i][j] == 0)
        return 0;
    grid[i][j] = 0;

    // 队列中存储的是个二维数组，这个二维数组就是格子的坐标
    queue<pair<int, int>> q;
    // 添加到队列的末尾
    q.push({i, j});

    // 分别表示右，左，下，上，四个方向
    vector<pair<int, int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    int res = 1;

    while (!q.empty()) {
        // 从队列的头部移除一个元素
        pair<int, int> pos = q.front();
        q.pop();

        // 然后从pos坐标的4个方向再分别查找
        for (auto dir : dirs) {
            int x = dir.first + pos.first;
            int y = dir.second + pos.second;

            // 边界条件的判断
            if (x < 0 || x >= m || y < 0 || y >= n || grid[x][y] == 0) {
                continue;
            }

            grid[x][y] = 0;
            res++;
            q.push({x, y});
        }
    }
    return res;
}

int maxAreaOfIsland(vector<vector<int>>& grid) {
    int maxArea = 0;
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[0].size(); j++) {
            if (grid[i][j] == 1) { // 如果当前位置是1，开始计算
                maxArea = max(maxArea, bfs(grid, i, j));
            }
        }
    }
    return maxArea;
}

int main() {
    // 示例网格
    vector<vector<int>> grid = {
        {0, 1, 0, 0, 1},
        {1, 1, 0, 0, 0},
        {0, 0, 1, 1, 0},
        {0, 0, 0, 1, 1}
    };

    int result = maxAreaOfIsland(grid);
    cout << "最大岛屿面积: " << result << endl;

    return 0;
}

        如果对图的遍历比较了解的话，这两种方式很容易想到，一个是沿着一个方向一直走下去，一个就像波浪一样，沿着一个点然后往四周一圈一圈的发散。