代码随想录|图论|07岛屿的最大面积

原创于 2025-06-27 19:11:33 发布 · 242 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #深度优先 #图论 #数据结构 #c++

leetcode:100. 岛屿的最大面积

题目

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，计算岛屿的最大面积。岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。后续 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出一个整数，表示岛屿的最大面积。如果不存在岛屿，则输出 0。

输入示例

输出示例

思路

需要计算每一个岛屿群的面积，然后找出最大的。

DFS方法

根据之前的解法，每个dfs处理当前的节点，那么在主函数中岛屿初始计数为0，因为在进入dfs之后，会立马进行增加。

// ======================================DFS第二种写法，处理当前节点======================================
#include <bits/stdc++.h>
using namespace std;

int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
// cnt设置的是全局变量，因为在每个dfs之前都需要置0
int cnt = 0;

void dfs(vector<vector<int>> &grid, vector<vector<bool>> &visited, int x, int y)
{
    // 终止条件：遇到海水或者已经遍历过的节点
    if (grid[x][y] == 0 || visited[x][y])
    {
        return;
    }
    // 处理当前节点
    cnt++;
    visited[x][y] = true;
    // 当前节点往下延伸，看四周的节点
    for (int i = 0; i < 4; i++)
    {
        int nextx = x + dir[i][0];
        int nexty = y + dir[i][1];
        if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size())
            continue;
        dfs(grid, visited, nextx, nexty);
    }
}

int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> grid[i][j];
        }
    }
    // result是最终结果，不断跟我们的最大面积进行比较
    int result = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (!visited[i][j] && grid[i][j] == 1)
                cnt = 0; // dfs处理的是当前节点，所以遇到陆地设为0，进入dfs之后才开始cnt++
            dfs(grid, visited, i, j);
            result = max(result, cnt);
        }
    }
    cout << result << endl;
    return 0;
}

BFS方法

void bfs(vector<vector<int>> &grid, vector<vector<bool>> &visited, int x, int y)
{
    queue<pair<int, int>> q;
    q.push({x, y});
    visited[x][y] = true;   // 只要加入队列就进行标记
    cnt++;
    while (!q.empty())
    {
        pair<int, int> cur = q.front();
        q.pop();
        int curx = cur.first;
        int cury = cur.second;
        for (int i = 0; i < 4; i++)
        {
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1];
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size())
                continue;
            if (grid[nextx][nexty] == 1 && !visited[nextx][nexty])
            {
                q.push({nextx, nexty});
                visited[nextx][nexty] = true;
                cnt++;
            }
        }
    }
}

int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> grid[i][j];
        }
    }
    int result = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (grid[i][j] == 1 && !visited[i][j])
            {
                cnt = 0;
                bfs(grid, visited, i, j);
                result = max(result, cnt);
            }
        }
    }
    cout << result << endl;
    return 0;
}