有基础班_day08课上题目

zxcvbnm

2025-07-08 16:51:43

发布于：上海

21阅读

0回复

0点赞

题目
广度优先搜索(一) - 抓住那头牛
广度优先搜索(一) - 迷宫
广度优先搜索(一) - 奇怪的电梯
广度优先搜索(一) - 仙岛求药
广度优先搜索(一) - 马的遍历
广度优先搜索(二) - 图像渲染
广度优先搜索(二) - 岛屿数量

广度优先搜索(一) - 抓住那头牛

题目分析

农夫和牛都位于数轴上，农夫希望通过最短的时间抓住牛。农夫可以选择三种不同的移动方式：向前一格、向后移动一格，或者是将当前位置乘以 2。每次移动花费一分钟，农夫的目标是抓住牛，并求出最少需要多少分钟。

这就是一个典型的图搜索问题，其中每个点代表数轴上的一个位置，每种移动方式都代表从当前点到相邻点的边。我们可以使用 广度优先搜索 (BFS) 来解决此问题，因为 BFS 可以保证找到最短路径。

关键点：

题目可以视为在数轴上进行搜索，从农夫的起点 N 开始，尝试通过合法的移动方式走到牛的位置 K。
由于 BFS 是无权图的最短路径算法，因此它非常适合解决此类问题。

输入输出

输入：

两个整数 N 和 K，分别表示农夫和牛的位置。

输出：

一个整数，表示农夫最少需要多少分钟才能抓住牛。

解题思路

初始化状态：我们可以把每个位置视作一个节点，农夫从起点 N 开始，通过 BFS 找到最短时间到达牛的位置 K。
BFS搜索过程：
- 使用一个队列来进行广度优先搜索，队列保存当前节点的状态。
- 记录每个位置的最短时间，避免重复访问。
- 对每个当前位置进行三种可能的移动：
  - 向左移动一格 (x-1)
  - 向右移动一格 (x+1)
  - 跳到 2*x
- 访问到牛的位置 K 时，直接输出当前的步数，即为所需的最少时间。
边界条件：注意不要越界，即保证每个位置都在 [0, 100000] 范围内。

复杂度分析

时间复杂度：每个位置最多被访问一次，因此时间复杂度为 O(N)，其中 N = 100000。
空间复杂度：需要记录每个位置的最短步数，空间复杂度为 O(N)。

代码实现

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

const int N = 100000;  // 数轴的最大范围

int d[N + 10];  // 记录每个位置的最小步数

int main() {
    int n, k;
    cin >> n >> k;

    // 初始化每个位置的步数为一个很大的值（无穷大）
    for (int i = 0; i <= N; i++) {
        d[i] = 0x7fffffff;
    }

    // 使用队列进行广度优先搜索
    queue<int> q;
    q.push(n);  // 将农夫的起始位置放入队列
    d[n] = 0;   // 农夫起始位置的步数为0

    while (!q.empty()) {
        int x = q.front();  // 取出队列中的一个位置
        q.pop();  // 队列出队

        if (x == k) {  // 如果当前位置就是牛的位置，返回步数
            cout << d[k] << endl;
            break;
        }

        // 检查并访问邻居节点（即能从当前位置到达的相邻位置）
        // 向左移动
        if (x - 1 >= 0 && d[x - 1] > d[x] + 1) {
            d[x - 1] = d[x] + 1;
            q.push(x - 1);
        }
        
        // 向右移动
        if (x + 1 <= N && d[x + 1] > d[x] + 1) {
            d[x + 1] = d[x] + 1;
            q.push(x + 1);
        }

        // 跳到2 * x
        if (2 * x <= N && d[2 * x] > d[x] + 1) {
            d[2 * x] = d[x] + 1;
            q.push(2 * x);
        }
    }

    return 0;
}

广度优先搜索(一) - 迷宫

题目分析

给定一个迷宫，由若干行若干列的格子组成，部分格子被障碍物 # 占据，部分格子为空地 .。我们需要从迷宫的左上角（(1,1)）出发，走到右下角（(R, C)），求出最少的步数。每次移动只能在水平方向或垂直方向进行，不能斜着走，且起点和终点都是空地。

关键点：

最短路径问题：这是一个典型的图搜索问题，网格上的每个位置就是一个节点，能够走的格子是相邻的节点，目标是找出从起点到终点的最短路径。
使用广度优先搜索（BFS）：BFS 是解决无权图最短路径问题的经典算法，能够确保最先访问到的路径是最短路径。

输入输出

输入：
- 两个整数 R 和 C，表示迷宫的行数和列数。
- 接下来是 R 行，每行 C 个字符，表示迷宫布局。空地用 . 表示，障碍物用 # 表示。
输出：
- 输出从左上角 (1,1) 到右下角 (R, C) 的最小步数。

解题思路

数据结构：
- 用一个 vis 数组记录每个位置是否被访问过。
- 使用一个队列 q 来进行广度优先搜索（BFS）。每次从队列中取出一个节点，处理它的四个邻居节点（上下左右），并加入队列。
BFS过程：
- 从起点 (1, 1) 开始，初始化步数为 0。
- 逐步遍历所有能走的路径，直到到达终点 (R, C)。
- 如果某个邻居节点是空地且未被访问过，加入队列，并记录其步数。
结束条件：
- 当队列中出队的节点是终点 (R, C) 时，输出其步数。
边界检查：
- 确保每次移动都不越界且目标位置是空地。

代码实现

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

char mp[50][50];  // 存储迷宫
int vis[50][50];  // 记录访问标记
int dir[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};  // 上下左右四个方向

struct node {
    int x, y;  // 当前坐标
    int step;  // 当前步数
};

int main() {
    int r, c;
    cin >> r >> c;
    
    // 输入迷宫布局
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            cin >> mp[i][j];
        }
    }

    // 使用队列进行BFS
    queue<node> q;
    q.push({1, 1, 0});  // 起点 (1,1) 步数为 0
    vis[1][1] = 1;       // 标记起点已访问

    while (!q.empty()) {
        node now = q.front();
        q.pop();

        // 到达终点，输出步数
        if (now.x == r && now.y == c) {
            cout << now.step;
            break;
        }

        // 遍历当前节点的四个邻居
        for (int i = 0; i < 4; i++) {
            node next;
            next.x = now.x + dir[i][0];  // 计算下一个位置
            next.y = now.y + dir[i][1];
            next.step = now.step + 1;     // 步数加 1

            // 检查下一个位置是否合法
            if (next.x >= 1 && next.x <= r && next.y >= 1 && next.y <= c) {
                // 如果该位置是空地且没有被访问过
                if (!vis[next.x][next.y] && mp[next.x][next.y] == '.') {
                    q.push(next);  // 将该位置加入队列
                    vis[next.x][next.y] = 1;  // 标记该位置已访问
                }
            }
        }
    }

    return 0;
}

广度优先搜索(一) - 奇怪的电梯

题目分析

在这道题目中，我们需要模拟一个奇怪的电梯。每个楼层都有一个数字，表示从当前楼层按“上”或“下”按钮时，电梯能到达的楼层。我们的目标是从楼层 A 到楼层 B，通过按按钮最少的次数来实现。

关键点：

电梯有四个按钮：开、关、上、下。每个楼层的数字 K[i] 指定了电梯能上下的层数（即当前楼层能到达的层数）。
我们需要用广度优先搜索（BFS）来找到从楼层 A 到楼层 B 的最短路径，因为这是一个最短路径问题，BFS 能有效地解决。

输入输出：

输入：
- N：楼层数
- A：起始楼层
- B：目标楼层
- K[i]：每个楼层上的数字，决定了电梯能上升或下降的楼层数。
输出：
- 输出从楼层 A 到楼层 B 所需的最少按键次数，若无法到达则输出 -1。

解题思路

建模问题：
- 每个楼层可以看做一个节点，楼层之间的“上下”操作可以看做图中的边。
- BFS 能够保证找到从起点到终点的最短路径。
BFS过程：
- 从起始楼层 A 开始，初始化步数为 0。
- 每次按“上”按钮或“下”按钮移动，更新目标楼层。
- 遇到未访问的楼层，加入队列，并更新步数。
- 如果队列中取出的楼层是目标楼层 B，则输出步数并结束。
边界条件：
- 如果楼层已访问过，就不再重复访问。
- 判断按“上”和“下”按钮是否能到达合法的楼层。

代码实现

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

int main() {
    int N, A, B;
    cin >> N >> A >> B;
    
    vector<int> K(N + 1);  // 每层的数字，表示上下的楼层数
    for (int i = 1; i <= N; i++) {
        cin >> K[i];
    }
    
    // 用一个数组来标记每个楼层是否被访问过
    vector<bool> visited(N + 1, false);
    
    // 队列存放每一层和按键的次数
    queue<pair<int, int>> q;
    q.push({A, 0});  // 从起始楼层A出发，按键次数为0
    visited[A] = true;
    
    while (!q.empty()) {
        int current = q.front().first;  // 当前楼层
        int steps = q.front().second;   // 按键次数
        q.pop();
        
        // 如果到达目标楼层B，输出结果
        if (current == B) {
            cout << steps << endl;
            return 0;
        }
        
        // 按“上”按钮，去到当前楼层 + K[current]
        if (current + K[current] <= N && !visited[current + K[current]]) {
            visited[current + K[current]] = true;
            q.push({current + K[current], steps + 1});
        }
        
        // 按“下”按钮，去到当前楼层 - K[current]
        if (current - K[current] >= 1 && !visited[current - K[current]]) {
            visited[current - K[current]] = true;
            q.push({current - K[current], steps + 1});
        }
    }
    
    // 如果队列为空仍然没有找到目标楼层，输出-1
    cout << -1 << endl;
    return 0;
}

广度优先搜索(一) - 仙岛求药

题目分析

这道题目是一个经典的路径最短问题，可以使用广度优先搜索（BFS）来求解。目标是在迷宫中寻找从起点（李逍遥的起始位置）到目标（仙药所在的位置）最短路径，同时避开含有怪物的方格。

关键点：

迷阵描述：
- @：起始位置，李逍遥的起点。
- .：安全通行的方格。
- #：有怪物的方格，不能通行。
- *：仙药所在的位置，目标位置。
移动规则：
- 可以在上下左右四个方向上移动。
- 只能经过 . 和 @ 方格，# 方格不能通行。
要求：
- 使用最少的步数从起点 @ 移动到目标 *。
- 如果无法到达目标，输出 -1。

解题思路

广度优先搜索（BFS）：
- BFS 是求解最短路径问题的经典算法，能够保证在无权图中找到从起点到目标的最短路径。
- BFS 通过逐层扩展来探索所有可能的路径，直到找到目标为止。
步骤：
- 从起点 @ 开始进行 BFS。
- 每次访问一个新的方格时，记录它的步数。
- 使用队列来存储待访问的节点，每访问一个节点就检查其相邻的四个方向。
- 如果遇到目标 *，输出当前步数并结束。
- 如果队列空了还没有找到目标，说明无法到达目标，输出 -1。
时间复杂度：
- BFS 的时间复杂度是 O(M * N)，其中 M 是迷阵的行数，N 是迷阵的列数。因为每个方格最多会被访问一次。

代码实现

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

int M, N;
vector<vector<char>> maze;
vector<vector<int>> dist;

int dx[] = {-1, 1, 0, 0}; // 上下左右的方向
int dy[] = {0, 0, -1, 1};

bool is_valid(int x, int y) {
    return x >= 0 && x < M && y >= 0 && y < N && maze[x][y] != '#';
}

int bfs(int startX, int startY) {
    queue<pair<int, int>> q; // 存储坐标
    dist[startX][startY] = 0; // 起始位置步数为 0
    q.push({startX, startY});
    
    while (!q.empty()) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        
        // 如果到达目标，返回步数
        if (maze[x][y] == '*') {
            return dist[x][y];
        }
        
        // 遍历四个方向
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            
            if (is_valid(nx, ny) && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }
    
    // 如果遍历结束没有找到目标，返回 -1
    return -1;
}

int main() {
    cin >> M >> N;
    maze.resize(M, vector<char>(N));
    dist.resize(M, vector<int>(N, -1)); // 初始化距离数组，-1表示未访问
    
    int startX, startY;
    
    // 读取迷阵并找到起始点的位置
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            cin >> maze[i][j];
            if (maze[i][j] == '@') {
                startX = i;
                startY = j;
            }
        }
    }
    
    // 从起始点开始 BFS
    int result = bfs(startX, startY);
    
    cout << result << endl;
    return 0;
}

广度优先搜索(一) - 马的遍历

题目分析

题目要求我们计算马从给定的起始位置到棋盘上每一个位置的最少步数，类似于一个多源最短路径问题，适合使用广度优先搜索（BFS）来求解。

关键点：

马的移动方式：
- 马可以在棋盘上移动，每次可以选择8个方向：
```
(-2, -1), (-1, -2), (1, -2), (2, -1),
(2, 1), (1, 2), (-1, 2), (-2, 1)
```
- 每次移动的步数为 1。
目标：
- 从给定的起点 (x, y) 开始，计算到达棋盘上每个位置的最少步数。
- 如果某个位置不可达，输出 -1。
棋盘大小：
- 棋盘的大小为 n × m，最大为 400 × 400，即最多有 160,000 个格子。
数据范围：
- 1 ≤ n, m ≤ 400
- 起始位置 (x, y) 是有效的位置，且 1 ≤ x ≤ n，1 ≤ y ≤ m。

解题思路

广度优先搜索（BFS）：
- BFS 是解决单源最短路径问题的经典方法，适合处理这种图结构的最短步数问题。
- 使用 BFS 从起点 (x, y) 开始，逐步扩展到周围的格子，并更新到达每个格子的最短步数。
- 我们使用一个二维数组 dist 来存储每个格子的步数，初始化为 -1，表示不可达。起始点的步数为 0，然后通过 BFS 更新其他格子的步数。
边界条件：
- 检查每次移动是否越界。
- 如果遇到不可达的格子，输出 -1。
实现细节：
- 使用一个队列 queue 存储当前需要访问的格子。
- 从队列中取出一个格子，检查其相邻的8个格子，如果相邻格子在棋盘范围内且未被访问过，则将其加入队列并更新步数。

代码实现

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

const int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2}; // 马的8个移动方向
const int dy[] = {-1, -2, -2, -1, 1, 2, 2, 1};

int main() {
    int n, m, x, y;
    cin >> n >> m >> x >> y;
    x--; y--; // 将输入的起点坐标转为0-based索引
    
    vector<vector<int>> dist(n, vector<int>(m, -1)); // 用于存储每个格子的最小步数
    queue<pair<int, int>> q; // 队列存储待访问的格子
    dist[x][y] = 0; // 起点步数为0
    q.push({x, y});
    
    // 广度优先搜索
    while (!q.empty()) {
        int cx = q.front().first;
        int cy = q.front().second;
        q.pop();
        
        // 遍历8个方向
        for (int i = 0; i < 8; i++) {
            int nx = cx + dx[i];
            int ny = cy + dy[i];
            
            // 如果新的坐标在棋盘范围内且未访问过
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[cx][cy] + 1;
                q.push({nx, ny});
            }
        }
    }
    
    // 输出结果
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << dist[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

广度优先搜索(二) - 图像渲染

题目分析

题目要求给定一个 n × m 的图像，并从一个指定的点 [x, y] 开始上色，将与该点相连且颜色相同的区域全部涂上一个新的颜色。

关键点：

起始点与颜色：
- 从指定的点 [x, y] 开始上色，并将所有与该点相连（通过上下左右连接）的且颜色相同的区域，涂成目标颜色。
问题性质：
- 这是一个图像区域上色问题，可以看作是一个 图的连通分量 问题。通过 BFS 或 DFS 遍历所有相连且颜色相同的点，逐一上色。
数据范围：
- 图像的大小为 n × m，最大为 50 × 50，所以最大有 2500 个点，适合使用 BFS 或 DFS 来解决。

解题思路

BFS/DFS 进行区域遍历：
- 使用 BFS 或 DFS，从起始点 [x, y] 开始，遍历所有与之颜色相同的相连点，并将其涂上目标颜色。
- BFS 更适合处理这种遍历问题，使用队列来存储待访问的节点。
边界检查：
- 在 BFS 中，要检查每次移动是否越界，同时确保当前点的颜色与起始点的颜色相同，才进行涂色操作。
输出：
- 输出修改后的图像，每行打印一行。

代码实现

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

int n, m;
vector<vector<int>> image;

const int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右四个方向

// 检查当前位置是否在图像范围内
bool is_valid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m;
}

void bfs(int x, int y, int target_color, int new_color) {
    if (image[x][y] != target_color) return; // 如果起始点的颜色和目标颜色不一样，直接返回
    
    queue<pair<int, int>> q;
    q.push({x, y});
    image[x][y] = new_color; // 将起始点的颜色改为新颜色

    while (!q.empty()) {
        int cx = q.front().first;
        int cy = q.front().second;
        q.pop();

        // 遍历当前节点的上下左右四个方向
        for (int i = 0; i < 4; i++) {
            int nx = cx + dir[i][0];
            int ny = cy + dir[i][1];

            // 如果新位置在图像内且颜色相同，进行上色
            if (is_valid(nx, ny) && image[nx][ny] == target_color) {
                image[nx][ny] = new_color;
                q.push({nx, ny});
            }
        }
    }
}

int main() {
    cin >> n >> m;
    image.resize(n, vector<int>(m));

    // 输入图像
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> image[i][j];
        }
    }

    // 输入上色起点和目标颜色
    int x, y, a;
    cin >> x >> y >> a;
    x--; y--; // 转为0-based坐标

    // 获取起始点颜色
    int target_color = image[x][y];

    // 执行 BFS 上色
    bfs(x, y, target_color, a);

    // 输出结果
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << image[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

广度优先搜索(二) - 图像渲染

题目分析

我们需要将图像中的一部分进行上色，要求通过起始点 [x, y] 开始，递归地将与之相连且颜色相同的区域都改为目标颜色。此问题可以视为一个图像填充问题，类似于“油漆桶”问题。

关键点：

上色的起始点：
- 从起始点 [x, y] 开始进行颜色更改。
颜色传播：
- 需要遍历与起始点相连的所有区域（上下左右），并且颜色相同的区域都要改变成目标颜色。
边界判断：
- 需要保证当前的操作不会越界，同时检查当前点的颜色是否与起始点颜色相同。

解题思路

BFS/DFS 进行区域填充：
- 使用 BFS 或 DFS 来从起始点开始逐步扩展区域，所有与起始点颜色相同的相邻区域都会被涂上目标颜色。
BFS 的好处：
- BFS 通过队列来逐步处理每一层的节点，适合处理这类层层扩展的区域问题。
数据范围：
- 图像的大小为 n × m，最大为 50 × 50，所以最多有 2500 个点，适合使用 BFS 来解决。

代码实现

#include <bits/stdc++.h>
using namespace std;

// 定义方向数组（上下左右）
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};

// 定义地图数组用于储存
int MAP[102][102];

// 结构体定义节点
struct node {
    int x, y;
};

int main() {
    int n, m;
    cin >> n >> m;

    // 输入地图
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> MAP[i][j];
        }
    }

    // 输入起始点和目标颜色z
    int x, y, z;
    cin >> x >> y >> z;

    // 如果起始点的颜色与目标颜色相同，直接输出图像
    if (z == MAP[x][y]) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                cout << MAP[i][j] << " ";
            }
            cout << endl;
        }
        return 0;
    }

    // 定义队列并将起始点压入队列
    queue<node> q;
    q.push({x, y});

    // 保存起始点的颜色，并修改起始点颜色为目标颜色
    int Color = MAP[x][y];
    MAP[x][y] = z;

    // BFS 进行区域扩展
    while (!q.empty()) {
        node now = q.front();
        q.pop();

        // 朝四个方向搜索
        for (int i = 0; i < 4; i++) {
            int fx = now.x + dx[i];
            int fy = now.y + dy[i];

            // 下一步的位置未超出地图边界且颜色相同
            if (fx > 0 && fy > 0 && fx <= n && fy <= m && MAP[fx][fy] == Color) {
                // 将当前位置颜色更改为目标颜色
                MAP[fx][fy] = z;
                // 将该位置加入队列继续扩展
                q.push({fx, fy});
            }
        }
    }

    // 输出修改后的图像
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cout << MAP[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

广度优先搜索(二) - 岛屿数量

题目分析

本题要求我们计算一个二维地图中岛屿的数量。地图由 1 和 0 组成，1 表示陆地，0 表示水域。岛屿是由连接在一起的陆地块组成的，陆地块通过水平方向或垂直方向相邻。如果两个陆地块通过一个连续的连接形成一个岛屿，则它们属于同一个岛屿。

思路

我们需要遍历整个地图，并对于每个陆地块（1），如果它没有被访问过，就启动一个 BFS 或 DFS 来标记与之相连的所有陆地块（将这些陆地块标记为 0 或已访问），然后统计岛屿的数量。

关键点：

岛屿定义：一个岛屿是由一群陆地块组成的，这些陆地块通过水平方向和垂直方向相邻连接。
遍历策略：使用广度优先搜索（BFS）或深度优先搜索（DFS）来遍历每个岛屿。每当遇到一个未被访问的陆地块（1），就启动 BFS/DFS 来遍历并标记所有与之连接的陆地块。
边界检查：在进行搜索时，需要确保不会访问到地图外部的区域。

BFS/DFS

BFS：广度优先搜索通过队列来处理每个陆地块，并逐步检查它的相邻块。
DFS：深度优先搜索通过递归来处理每个陆地块，并访问所有相连的陆地块。

解题思路：

对每个陆地块进行遍历。
如果当前陆地块没有被访问过，就启动 BFS/DFS 来标记所有与它相连的陆地块，并增加岛屿数量。
最终输出岛屿的总数。

代码实现

#include <bits/stdc++.h>
using namespace std;

// 定义方向数组，上下左右四个方向
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};

// 定义地图数组用于存储地图数据
int MAP[102][102], n, m;

// 结构体定义，用于存储当前访问的坐标
struct node {
    int x, y;
};

// BFS 实现
void bfs(int x, int y) {
    // 定义队列并将起始点压入队列
    queue<node> q;
    q.push({x, y});
    
    // 开始 BFS，遍历相连的陆地块
    while (!q.empty()) {
        node now = q.front();
        q.pop();
        
        // 朝四个方向进行搜索
        for (int i = 0; i < 4; i++) {
            int fx = now.x + dx[i];
            int fy = now.y + dy[i];
            
            // 判断是否在地图范围内，并且当前位置为陆地
            if (fx > 0 && fy > 0 && fx <= n && fy <= m && MAP[fx][fy] == 1) {
                // 将该位置标记为水域（已访问过）
                MAP[fx][fy] = 0;
                // 将该位置压入队列，继续扩展
                q.push({fx, fy});
            }
        }
    }
}

int main() {
    // 输入地图的大小
    cin >> n >> m;

    // 输入地图
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> MAP[i][j];
        }
    }

    // 统计岛屿的数量
    int sum = 0;

    // 遍历地图
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            // 如果当前为陆地（1），并且没有被访问过，启动 BFS
            if (MAP[i][j] == 1) {
                sum++;           // 岛屿数量加1
                MAP[i][j] = 0;   // 将当前位置标记为访问过
                bfs(i, j);       // 启动 BFS，标记该岛屿的所有陆地
            }
        }
    }

    // 输出岛屿的数量
    cout << sum << endl;

    return 0;
}

有帮助，赞一个

去预览

0/2000

这里空空如也

广度优先搜索(一) - 抓住那头牛

题目分析

关键点：

输入输出

输入：

输出：

解题思路

复杂度分析

代码实现

广度优先搜索(一) - 迷宫

题目分析

关键点：

输入输出

解题思路

代码实现

广度优先搜索(一) - 奇怪的电梯

题目分析

关键点：

输入输出：

解题思路

代码实现

广度优先搜索(一) - 仙岛求药

题目分析

关键点：

解题思路

代码实现

广度优先搜索(一) - 马的遍历

题目分析

关键点：

解题思路

代码实现

广度优先搜索(二) - 图像渲染

题目分析

关键点：

解题思路

代码实现

广度优先搜索(二) - 图像渲染

题目分析

关键点：

解题思路

代码实现

广度优先搜索(二) - 岛屿数量

题目分析

思路

关键点：

BFS/DFS

解题思路：

代码实现

热门讨论