Leetcode刷题 | Day50_图论02_岛屿问题01_dfs两种方法+bfs一种方法

已于 2025-04-29 06:49:10 修改
阅读量1k 收藏 10
点赞数 9
文章标签： leetcode 图论 算法 数据结构 c++ 深度优先 广度优先
于 2025-04-29 06:18:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52152177/article/details/147595782
版权

 一、学习任务

  • 99. 岛屿数量_深搜dfs代码随想录
  • 99. 岛屿数量_广搜bfs
  • 100. 岛屿的最大面积
  • 101. 孤岛的总面积

第一类DFS（主函数中处理第一个节点，DFS处理相连节点）：

  • 主函数中先将起始节点标记为已访问
  • DFS函数中不处理起始节点，直接判断邻节点是否有效、未访问，然后再处理

第二类DFS（DFS直接处理当前节点）：

  • 主函数不处理起始节点
  • DFS函数开头就判断当前节点是否有效，无效则返回，有效则处理当前节点，标记为已访问，然后递归处理邻节点

二、具体题目

1.99岛屿数量_深搜dfs99. 岛屿数量

题目描述：

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

输入描述：

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

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

输出描述：

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

版本一调用dfs 的条件判断，放在，版本二的终止条件位置上。（dfs函数内部有差别）

版本一的写法：下一个节点是否能合法已经判断完了，传进dfs函数的就是合法节点。

版本二的写法：不管节点是否合法，上来就dfs，然后在终止条件的地方进行判断，不合法再return。

理论上来讲，版本一的效率更高一些，因为避免了没有意义的递归调用，在调用dfs之前，就做合法性判断。但从写法来说，可能版本二更利于理解一些。

版本一：

  • dfs函数直接处理传入节点连接的四个节点
  • 所以主函数中需要先将这个传入节点的visited数组值设为true，再dfs处理连接的节点
  • dfs函数中，连接的节点被判断为未访问的岛屿后，再对其visited数组值设为true，再dfs处理连接的节点

两个区别：visited再哪里设置；未访问岛屿在哪里判断

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

int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void dfs(const vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    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 (visited[nextx][nexty] == false && grid[nextx][nexty] == 1) { // 未访问过，同时，是陆地（grid = 1）才继续搜索，不是陆地就直接搜索下一个方向（只能横竖连着才算一个岛）
            visited[nextx][nexty] = true;
            dfs(grid, visited, nextx, nexty);
        }
    }
}

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] == false && grid[i][j] == 1) {
                visited[i][j] = true;
                result++; // 遇到没访问过的陆地，+1
                dfs(grid, visited, i, j); // 将与这个没访问陆地连接的陆地都标记上true，他们属于同一个岛，防止这些点继续被访问，被错误的计算为“未发现的新岛”，影响result计数；（！！保证连在一起的一个岛只被计数一次！！）
            }
        }
    }
    cout << result << endl;
}

版本二： 

  • dfs函数直接处理传入节点
  • 所以主函数中，可以直接用dfs处理该节点
  • dfs函数中，先判断该节点是不是未访问的岛屿；不是就return，是就对其visited数组值设为true，再dfs处理连接的节点

两个区别：visited再哪里设置；未访问岛屿在哪里判断

#include <iostream>
#include <vector>
using namespace std;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void dfs(const vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    if (visited[x][y] == true || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水
    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));
    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] == false && grid[i][j] == 1) {
                result++; // 遇到没访问过的陆地，+1
                dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
            }
        }
    }
    cout << result << endl;
}

2.99岛屿数量_广搜bfs99. 岛屿数量

重点：加入队列就代表走过，立即标记，而不是从队列拿出来的时候再去标记。

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

int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
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(); // 队列前面元素出队列，处理它连接的四个点
        for (int i = 0; i < 4; i++) {
            int nextx = cur.first + dir[i][0];
            int nexty = cur.second + dir[i][1];
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 越界了，直接跳过，搜索当前点的下一个方向
            if (visited[nextx][nexty] == false && 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] == false && grid[i][j] == 1) {
                result++; // 遇到没访问过的陆地，+1
                bfs(grid, visited, i, j); // 直接处理这个点，并将与其链接的陆地都标记上 true
            }
        }
    }
    cout << result << endl;
}

3.100岛屿的最大面积100. 岛屿的最大面积

题目描述

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

输入描述

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

输出描述

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

版本一dfs：dfs处理当前节点的相邻节点，即主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地 

#include <iostream>
#include <vector>
using namespace std;
int count;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    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 (visited[nextx][nexty] == false && grid[nextx][nexty] == 1) { // 在这里判断；没有访问过的,同时是陆地的
            visited[nextx][nexty] = true; // 在这里处理
            count++; // 在这里处理；累计传入节点的连接节点的面积
            dfs(grid, visited, nextx, nexty);
        }
    }
}

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] == false && grid[i][j] == 1) {
                visited[i][j] = true; // 下面的dfs是处理相连节点的，所以这里要把当前节点visited数组值设置完
                count = 1;  // 因为下面的dfs处理下一个与之相连的节点，所以这里遇到陆地了就先计数，dfs处理接下来的相邻陆地
                dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                result = max(result, count);
            }
        }
    }
    cout << result << endl;

}

版本二dfs：dfs处理当前节点，即主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地

#include <iostream>
#include <vector>
using namespace std;
int count;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    if (visited[x][y] == true || grid[x][y] == 0) return; // 在这里判断；终止条件：访问过的节点 或者 遇到海水
    visited[x][y] = true; // 在这里处理；因为main里的dfs处理当前节点，所以main中不需要处理当前节点的visited数组值，放在这里处理
    count++; // 在这里处理；因为main里的dfs处理当前节点，所以main中不需要考虑当前节点的面积，放在这里处理
    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));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
    vector<vector<bool>> visited = vector<vector<bool>>(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] == false && grid[i][j] == 1) {
                count = 0; // 因为dfs处理当前节点，所以遇到陆地计数为0，（现在还不需要考虑它的面积，因为交给后序dfs考虑了）进dfs之后在开始从1计数
                dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                result = max(result, count);
            }
        }
    }
    cout << result << endl;
}

版本三bfs写法：处理当前节点，所以count++放在bfs函数里面的前面

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int count;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void bfs(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; // 加入队列就意味节点是陆地可到达的点
    count++;
    while(!que.empty()) {
        pair<int, int> cur = que.front();
        que.pop();
        for (int i = 0 ;i < 4; i++) {
            int nextx = cur.first + dir[i][0];
            int nexty = cur.second + dir[i][1];
            if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 越界
            if (visited[nextx][nexty] == false && grid[nextx][nexty] == 1) { // 节点没有被访问过且是陆地
                visited[nextx][nexty] = true;
                count++;
                que.push({nextx, nexty});
            }
        }
    }
}

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] == false && grid[i][j] == 1) {
                count = 0;
                bfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                result = max(result, count);
            }
        }
    }
    cout << result << endl;
}

4.101孤岛的总面积101. 孤岛的总面积

题目描述

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

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

输入描述

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

输出描述

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

版本一dfs：dfs处理当前节点的连接节点 

#include <iostream>
#include <vector>
using namespace std;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void dfs(vector<vector<int>>& grid, int x, int y) {
    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] == 1) {
            grid[nextx][nexty] = 0;
            dfs (grid, nextx, nexty);
        }
    }
}

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) {
            grid[i][0] = 0;
            dfs(grid, i, 0);
        }
        if (grid[i][m - 1] == 1) {
            grid[i][m - 1] = 0;
            dfs(grid, i, m - 1);
        }
    }
    // 从上边和下边 向中间遍历
    for (int j = 0; j < m; j++) {
        if (grid[0][j] == 1) {
            grid[0][j] = 0;
            dfs(grid, 0, j);
        }
        if (grid[n - 1][j] == 1) {
            grid[n - 1][j] = 0;
            dfs(grid, n - 1, j);
        }
    }
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) count++;
        }
    }
    cout << count << endl;
}

版本二dfs：dfs直接处理当前节点

#include <iostream>
#include <vector>
using namespace std;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void dfs(vector<vector<int>>& grid, int x, int y) {
    if (grid[x][y] == 0) return;
    grid[x][y] = 0;
    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, nextx, nexty);
    }
}

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);
    }
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) count++;
        }
    }
    cout << count << endl;
}

bfs：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 四个方向
void bfs(vector<vector<int>>& grid, int x, int y) {
    queue<pair<int, int>> que;
    que.push({x, y});
    grid[x][y] = 0; // 只要加入队列，立刻标记
    while(!que.empty()) {
        pair<int ,int> cur = que.front(); 
        que.pop();
        for (int i = 0; i < 4; i++) {
            int nextx = cur.first + dir[i][0];
            int nexty = cur.second + 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});
                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);
    }
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) count++;
        }
    }

    cout << count << endl;
}
freyazzr
关注
谷歌师兄的leetcode刷题笔记-day_7_Premiers_programmes:day_7_Premiers_programmes
06-30
谷歌师兄的leetcode刷题笔记第七天 列表练习： 多 Caesar 这里有两个版本都可以使用。 每个人都做了自己的。 雷曼兄弟 Google 运行脚本时要小心。 更改或注释要运行的函数。 莎士比亚 运行脚本时要小心。 更改或注释...
leetcode刷题技巧-leetcode_random:一些leetcode问题的解决方法&随机码刷C++技能
07-06
总之，"leetcode_random"压缩包是一个宝贵的资源，它提供了一种结构化的方法来刷LeetCode题目，并通过C++编程语言加深对算法和数据结构的理解。通过深入研究这个项目，你不仅可以掌握C++编程，还能培养解决问题的...
Leetcode刷题 | Day51_图论03_岛屿问题02
weixin_52152177的博客
04-30 764
第二步：再遍历地图，遍历0的方格（因为要将0变成1），并统计该1（由0变成的1）周边岛屿面积，将其相邻面积相加在一起，遍历所有 0 之后，就可以得出 选一个0变成1 之后的最大面积。给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。
Day57_20250205_图论part3_99.岛屿数量深搜|99.岛屿数量广搜|100.岛屿的最大面积
爱因斯小柚的博客
02-09 704
注意有两个if判断条件相似，避免混淆扩展岛屿，只扩展到未访问的陆地//终止条件[未被访问过and遇到陆地] 扩展岛屿，只扩展到未访问的陆地，避免重复访问if(!只对新发现的岛屿进行dfs/如果发现新的岛屿[陆地没被访问过&&当前位置是陆地]if(!暂时掌握思路了，但是不能独立敲一遍代码，一刷先掌握思路。2种写法法1，只扩展到未访问的陆地，避免重复访问。法2，不管节点是否合法，先dfs,最后在终止条件的地方进行判断，不合法再return。写不出来bfs方法有点难。
Leetcode Day6 (图论I, dfs, bfs)
weixin_60829839的博客
08-20 367
虽然写的是easy但一点都不easy好吧, 什么时候多加1呢?当dfs每经过一个水域或者边界的时候, 就会增加1。主要的地方是res在哪里加, dfs的直接返回情况有哪些(一定要注意or grid[x][y] == ‘0’)当然不这样递归也可以, 但就需要对每一个递归开始初始化一个global variable。这个地方的区别就在于在哪里进行面积+=1的操作, 实际上本方法用的是递归。其实简单, 就先数一下几块地, 分别多大, 然后暴力尝试。
Day58_20250206_图论part3_101.孤岛的总面积|102.沉没孤岛|103.水流问题|104.建造最大岛屿
爱因斯小柚的博客
02-09 837
题目描述：给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。输入描述：第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。输出描述输出将孤岛“沉没”之后的岛屿矩阵。
Day56_20250204_图论part1_图论理论基础|深搜理论基础|98.所有可达路径|广搜理论基础
爱因斯小柚的博客
02-07 647
掌握邻接表和邻接图的代码写法挺复杂的，需要多练习几遍。
【代码随想录Day50】图论Part02
Shayne 的博客
10-23 926
【代码】【代码随想录Day50】图论Part02。
leetcode图论基础入门
忘眠的博客
03-10 509
文章目录leetcode 14天图论基础day : 1[733. 图像渲染](https://leetcode-cn.com/problems/flood-fill/)[200. 岛屿数量](https://leetcode-cn.com/problems/number-of-islands/)version 1.0version 2.0version 3.0 leetcode 14天图论基础 day : 1 733. 图像渲染 思路：dfs,需要注意的是：如果newColor = 中心点的数值，不能dfs
代码随想录算法训练day57---图论系列2《岛屿问题》
qq_38365428的博客
02-09 794
今天是算法营的第57天，希望自己能够坚持下来！今天继续图论part！今日任务：● 99.岛屿数量 深搜● 99.岛屿数量 广搜● 100.岛屿的最大面积1.使用int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};来获取下一步的坐标2.深度优先搜索dfs的终止条件可以放在开头，也可以放在调用递归前，区别是对函数是处理本次节点还是下一个节点。3.广度优先搜索bfs，一旦加入队列就要标记。明天继续加油！
代码随想录Day 51|题目：99.岛屿数量、100.岛屿的最大面积
LuckyYH__的博客
09-21 1360
BFS、DFS、并查集解决岛屿问题算法选择BFS：适用于层级遍历，可以找到最短路径，适合于岛屿问题因为它可以逐层扩展，直到所有相连的陆地都被访问。DFS：适用于深度遍历，可以探索所有可能的路径，适合于岛屿问题因为它可以深入探索每个岛屿直到尽头。并查集：适用于处理动态连通性问题，通过合并操作来识别和跟踪连通的组件，适合于岛屿问题因为它可以快速判断和合并相连的陆地。实现方式BFS：使用队列存储待访问的节点，逐层访问，每访问一个陆地节点，就将其所有未访问的相邻陆地节点加入队列。DFS。
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录_Java_下载.zip
04-30
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录_Java_下载.zip”中，包含的资源主要是关于Java编程语言实现的数据结构、排序算法、经典算法以及LeetCode刷题的代码实现。这些是计算机...
谷歌师兄的leetcode刷题笔记-TechSupportForGoogleProducts__DiscussionWithSrinivasa
06-30
谷歌师兄的leetcode刷题笔记谷歌产品技术支持__与 SrinivasanPichai 的讨论 #与 Srinivasan Pichai 的讨论 我不知道你们在做什么，但是每当我遇到 Google 产品的技术支持问题时，我都会给 Vasan Pichai 发电子邮件，...
leetcode刷题账号-leetcode_md:爬虫爬取关于leetcode问题及代码开头，并生成md文件
07-06
leetcode_md 目的 刷题 leetcode 并写 md 文件有些麻烦，为了节约时间，通过爬虫将 leetcode 上面的题和一些代码的开头爬取下来存入 sqlite3 ，并输入时间和某题的序号或标题可以自动生成关于某题的 md 文件。 srv....
【LeetCode Hot100】回溯篇
_Djhhh` blog
05-01 465
本文用于整理LeetCode Hot100中题目解答，因题目比较简单且更多是为了面试快速写出正确思路，只做简单题意解读和一句话题解方便记忆。但代码会全部给出，方便大家整理代码思路。
双指针算法详解（含力扣和蓝桥杯例题）
m0_74655006的博客
05-03 1047
双指针一般是由快慢指针和对撞指针这两部分组成，其中快慢指针一般是比对撞指针要难一些，我们需要通过题目的意思来设置合适的条件。然后枚举每一种情况就行。
Leetcode 3537. Fill a Special Grid
最新发布
codename_cys的博客
05-04 1281
Leetcode 3537. Fill a Special Grid
力扣面试150题--分隔链表
qq_46634167的博客
05-02 571
遍历链表，每一个点与值比较，比值小就继续，比值大就放到链表尾部即可。
力扣-数组-189轮转数组
夏末秋也凉的博客
04-30 225
k对数组大小取余，然后记录前k个数字，从后往前遍历到k，分别挪到iklennums的位置上。
蓝桥杯Python一周速成
03-13
<think>好的，我现在要处理用户关于“蓝桥杯Python一周速成”的查询。首先，我需要理解用户的需求。用户可能是在短时间内需要准备蓝桥杯Python组的比赛，时间紧迫，所以希望得到高效的学习策略和重点内容。 接下来，我应该考虑蓝桥杯Python组的考察范围。通常这类比赛会涉及基础语法、算法、数据结构，以及实际问题的解决能力。由于时间只有一周，用户不可能深入所有细节，因此需要筛选出高频考点和容易快速掌握的内容。 然后，我得规划出一周的学习计划。每天安排不同的主题，比如第一天基础语法，第二天数据结构，第三天算法入门，第四天真题训练，第五天模拟题，第六天查漏补缺，第七天复习调整。每个主题需要突出重点，例如基础语法中的循环、条件判断、函数；数据结构中的列表、字典、字符串处理；算法部分如排序、递归、动态规划基础。 还要考虑用户可能的基础情况。如果用户已经有一定Python基础，重点应放在算法和真题训练上；如果是零基础，可能需要更紧凑的安排，但一周时间确实紧张。不过用户提到“速成”，所以假设有一定的基础，但需要系统复习和强化。 然后，需要给出具体的学习建议。例如推荐哪些资源，官方题库的重要性，时间分配策略，以及调试能力的培养。同时提醒用户避免的误区，比如不要死记硬背代码，或者忽视真题。 可能遇到的问题是如何在短时间内高效掌握关键算法。这时候需要推荐常见的算法题型，如排序、查找、简单动态规划，并提供典型例题，比如斐波那契数列、背包问题等。但要注意复杂度，避免过于复杂的内容。 最后，总结部分需要鼓励用户，强调合理规划和专注的重要性，同时提醒调整心态，保持良好状态参赛。可能还需要提醒用户注意比赛规则和环境，比如蓝桥杯使用的评测系统，编程环境的熟悉等。 检查是否有遗漏点，比如是否需要提到具体的参考资料或在线资源？用户可能希望得到推荐的练习平台，比如蓝桥杯官网、LeetCode简单题、牛客网等。是否需要包含这些信息？根据用户的问题，可能不需要太具体的推荐，但给出一般性建议是合适的。 另外，确保回答结构清晰，分点明确，符合用户可见层的指令要求。使用中文，避免专业术语过于晦涩，同时保持逻辑连贯，帮助用户一步步解决问题。 现在需要将这些思考整理成一个结构化的回答，涵盖每日计划、重点内容、学习建议、注意事项等，确保用户能在一周内高效备考。</think>以下是针对蓝桥杯Python组**一周速成计划**的详细指南，结合高频考点和短期突破策略： --- ### **一、核心考点与优先级** 蓝桥杯Python组侧重**算法实现能力**和**实际问题建模**，重点掌握以下内容（按优先级排序）： 1. **基础语法**：输入输出（`input()`格式化处理）、列表推导式、字符串操作（切片、`split()`/`join()`） 2. **数据结构**：列表（排序、二维数组操作）、字典（计数、映射）、集合（去重） 3. **算法**： - **必考**：贪心算法（找零、活动选择）、DFS/BFS基础（迷宫问题）、动态规划（一维DP，如爬楼梯） - **高频**：排序（冒泡、快速排序）、递归（阶乘、斐波那契）、数学问题（质数判断、进制转换） 4. **真题题型**：日期计算、字符串处理、图论基础（最短路径简化版） --- ### **二、7天速成计划表** #### **Day 1-2：语法与数据结构突击** - **上午**： - 输入输出：处理多行输入（如`sys.stdin.read()`），格式化输出（`f-string`对齐） - 列表操作：合并`extend()`、排序`sorted(key=lambda)`、二维列表遍历（矩阵转置） - **下午**： - 字典应用：统计词频（`collections.defaultdict`）、键值反转 - 字符串技巧：`replace()`链式处理、正则表达式简单匹配（如`re.findall(r'\d+',s)`） #### **Day 3-4：算法入门与模板记忆** - **贪心算法**： - 典型题：硬币找零（优先大面值）、区间调度（按结束时间排序） - **DFS/BFS**： - 模板代码：迷宫路径计数（使用栈/队列）、岛屿问题 - **动态规划**： - 一维DP：背包问题（01背包简化版）、最长递增子序列（`O(n^2)`解法） #### **Day 5-6：真题实战与调试技巧** - **刷题策略**： - 近3年初赛真题（官网/题库），限时90分钟模拟 - 重点题型：日期类（闰年判断、星期计算）、数学逻辑（等差数列求和、质因数分解） - **调试技巧**： - 使用`print`定位错误（输出中间变量） - 边界测试：输入为空、极值（如n=0或1e5） #### **Day 7：查漏补缺与策略优化** - **易错点回顾**： - 循环边界错误（如`range(n)` vs `range(1,n+1)`） - 深拷贝/浅拷贝问题（二维列表使用`copy.deepcopy()`） - **时间分配策略**： - 简单题30分钟内AC，难题先写伪代码保部分分 --- ### **三、推荐资源与工具** 1. **练习平台**：蓝桥杯官方练习系统、洛谷（筛选“普及-”难度） 2. **代码模板**：整理DFS/BFS、快速排序等高频算法模板（手写记忆） 3. **效率工具**：使用Python内置函数（如`itertools.permutations`生成排列） --- ### **四、注意事项** - ❌ 避免死磕复杂算法（如线段树、网络流） - ✅ 考试时优先提交**部分正确**的代码（蓝桥杯按用例给分） - ✅ 注意Python特性：大整数运算无需优化，但递归深度默认限制（可设置`sys.setrecursionlimit`） --- 通过**真题驱动学习+模板化训练**，即使时间紧张也能有效提升应试能力。最后一天保持良好作息，调整心态应对比赛！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值