KamaCoder 101. 孤岛的总面积

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。

现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。

输入描述

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

输出描述

输出一个整数，表示所有孤岛的总面积，如果不存在孤岛，则输出 0。

在矩阵中心部分的岛屿，因为没有任何一个单元格接触到矩阵边缘，所以该岛屿属于孤岛，总面积为 1。

思路

本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。

在遇到地图周边陆地的时候，将1都变为0，此时地图为这样：

代码

C++深度优先搜索（dfs负责记录孤岛大小并将贴边岛屿标记为海洋，可以一起用是因为在将所有贴边岛屿标记为海洋之前不会更新count）

#include<iostream>
#include<vector>
using namespace std;

int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
int count;
void dfs(vector<vector<int>>& grid, int x, int y) {
    grid[x][y] = 0;
    count++;
    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;
        if (grid[nextx][nexty] == 0) continue;
        dfs(grid, nextx, nexty);
    }
    return;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    // 从左侧边，和右侧边向中间遍历
    for (int i = 0; i < n; ++i) {
        if (grid[i][0] == 1) dfs(grid, i, 0);
        if (grid[i][m-1] == 1) dfs(grid, i, m-1);
    }
    // 从上边和下边，向中间遍历
    for (int j = 0; j < m; ++j) {
        if (grid[0][j] == 1) dfs(grid, 0, j);
        if (grid[n-1][j] == 1) dfs(grid, n-1, j);
    }
    // 已经把贴边的岛屿都标记为海洋了，重新开始记录陆地
    count = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (grid[i][j] == 1) {
                dfs(grid, i, j);
            }
        }
    }
    cout << count << endl;
}

C++广度优先搜索（注意将nextx, nexty加入队列时，立刻标记为0，避免之后重新加入）

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
int count;
void bfs(vector<vector<int>>& grid, int x, int y) {
    queue<pair<int, int>> que;
    que.push({x, y});
    grid[x][y] = 0;
    count++;
    while(!que.empty()) {
        pair<int, int> cur = que.front(); que.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) {
                que.push({nextx, nexty});
                count++;
                grid[nextx][nexty] = 0; // 只要加入队列立刻标记
            }
        }
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    // 从左侧边，和右侧边向中间遍历
    for (int i = 0; i < n; ++i) {
        if (grid[i][0] == 1) bfs(grid, i, 0);
        if (grid[i][m-1] == 1) bfs(grid, i, m-1);
    }
    // 从上边和下边，向中间遍历
    for (int j = 0; j < m; ++j) {
        if (grid[0][j] == 1) bfs(grid, 0, j);
        if (grid[n-1][j] == 1) bfs(grid, n-1, j);
    }
    // 已经把贴边的岛屿都标记为海洋了，重新开始记录陆地
    count = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (grid[i][j] == 1) {
                bfs(grid, i, j);
            }
        }
    }
    cout << count << endl;
}

Python广度优先搜索

from collections import deque

n, m = list(map(int, input().strip().split()))
grid = [list(map(int, input().strip().split())) for _ in range(n)]

dirc = [[0, 1], [1, 0], [0, -1], [-1, 0]]
count = 0

def bfs(r, c):
    global count
    q = deque()
    q.append((r, c))
    grid[r][c] = 0
    count += 1
    
    while q:
        r, c = q.popleft()
        for dx, dy in dirc:
            nextr, nextc = r + dx, c + dy
            if (nextr < 0 or nextr >= n or nextc < 0 or nextc >= m):
                continue
            if grid[nextr][nextc] == 1:
                q.append((nextr, nextc))
                grid[nextr][nextc] = 0
                count += 1

for i in range(n):
    if grid[i][0] == 1: bfs(i, 0)
    if grid[i][m-1] == 1: bfs(i, m-1)
    
for j in range(m):
    if grid[0][j] == 1: bfs(0, j)
    if grid[n-1][j] == 1: bfs(n-1, j)

count = 0;
for i in range(n):
    for j in range(m):
        if grid[i][j] == 1: bfs(i, j)

print(count)