leetcode_day54

今日内容：

• 99. 岛屿数量
• 100. 岛屿的最大面积

岛屿数量

题目：

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

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。

后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述

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

思路：

遍历整个图，如果遇到没走过的1，就计数，并把其相邻的所有1都走一遍，如果遇到走过的1或0就跳过，最后返回计数。

代码

dfs版：

#include <bits/stdc++.h>
 
using namespace std;
#define rep(i, a, b) for(int i = a;i < b;i++)
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
void dfs(const vector<vector<int>> map, vector<vector<int>> & visited, int x, int y) {
    rep(i, 0, 4){
        int nextx = x + dir[i][0];
        int nexty = y + dir[i][1];
        if(nextx < 0 || nextx >= (int)map.size() || nexty < 0 || nexty >= (int)map[0].size() || visited[nextx][nexty] || map[nextx][nexty] == 0) continue;
        else {
            visited[nextx][nexty] = true;
            dfs(map, visited, nextx, nexty);
        }
    }
}
 
int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> map(N, vector<int>(M));
    rep(i, 0, N) {
        rep(j, 0, M) {
            cin >> map[i][j];
        }
    }
    vector<vector<int>> visited(N, vector<int>(M, false));
    int ans = 0;
    rep(i, 0, N){
        rep(j, 0, M) {
            if(map[i][j] == 1 && !visited[i][j]) {
                visited[i][j] = true;
                ans ++;
                dfs(map, visited, i, j);
            }
        }
    }
    cout << ans;
    return 0;
}

bfs版：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
 
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(const vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    queue<pair<int, int>> que;
    que.push({x, y});
    visited[x][y] = true; // 只要加入队列，立刻标记
    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 (!visited[nextx][nexty] && grid[nextx][nexty] == 1) {
                que.push({nextx, nexty});
                visited[nextx][nexty] = true; // 只要加入队列立刻标记
            }
        }
    }
}
 
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];
        }
    }
 
    vector<vector<bool>> visited(n, vector<bool>(m, false));
 
    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) {
                result++; // 遇到没访问过的陆地，+1
                bfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
            }
        }
    }
 
 
    cout << result << endl;
}

岛屿的最大面积

题目：

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

输入描述

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

输出描述

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

思路：

采用和上一道题相同的思路，只是不计数岛屿数量，改为在遍历岛屿时计数面积(格子数)，从中选出一个最大的面积返回。

代码

dfs版：

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

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向

int island = 0;

void dfs(const vector<vector<int>> grid, vector<vector<bool>> & visited, int x, int y) {
    for(int i = 0;i < 4;i++) {
        int _x = x + dir[i][0];
        int _y = y + dir[i][1];
        if(_x < 0 || _x >= grid.size() || _y < 0 || _y >= grid[0].size() || grid[_x][_y] == 0 || visited[_x][_y] == true) continue;
        else {
            visited[_x][_y] = true;
            island++;
            dfs(grid, visited, _x, _y);
        }
    }
}

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];
        }
    }

    vector<vector<bool>> visited(n, vector<bool>(m, false));

    int max = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if(grid[i][j] == 1 && visited[i][j] == false) {
                island = 1;
                visited[i][j] = true;
                dfs(grid, visited, i, j);
                max = max >= island ? max : island;
            }
        }
    }
    cout << max;
    return 0;
}

小结&注意

在bfs时，入队即为走过，需要立即将其状态visited置位，否则会重复遍历超时。