代码随想录Day17 图论-1

🕗 发布于 2024-09-24 07:55 图论算法

DFS和BFS基础

做图论这部分的题目DFS和BFS少不了

DFS是深搜沿着一条路一直搜索下去直到无法继续向下再通过回溯换一条路进行搜索

BFS是广搜就是从当前节点出发一直把当前节点所连接的所有节点都搜索过之后进入下一节点在开始相同的搜索过程

98.所有可达路径

题意很简单从1节点出发可以到5节点的所有路径用邻接矩阵构造图用path记录路径 ans记录所有的路径

dfs 从一条路走到底遍历当前节点所连接的节点放入path路径里然后再进入dfs深搜中下一个语句就是回溯语句从path里删除刚刚放入的元素

void dfs(const vector<vector<int>>& graph, int x, int n){
    if(x==n){
        ans.push_back(path);
    }
    for(int i=1;i<=n;i++){
        if(graph[x][i]==1){
            path.push_back(i);
            dfs(graph,i,n);
            path.pop_back();
        }
    }
}

99. 岛屿数量

本题规定了只有上下左右四个方向相连起来的就是一个岛屿本题要求存在的岛屿数量

dfs

首先我们需要需要一个dir数组规定四个方向在主函数里面如果遇到没有访问过的陆地就让岛屿的总数加1 然后进入dfs

dfs里面逻辑如果访问的节点访问过或者是水域就退出dfs 如果是没访问过的陆地就标记为访问过然后遍历四个方向用x，y分别记录坐标判断坐标是否越界然后进入dfs下一次搜索

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(const vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    if (visited[x][y] || 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 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
                dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
            }
        }
    }

bfs

bfs是要把当前节点所连接的节点都要遍历一遍再进行下一步所以我们也可以用到队列只要元素加入队列我们就标记为访问过然后当队列不为空的时候我们取出队列里面的元素就是当前所遍历的元素然后遍历四个方向判断边界是否越界如果这四个方向的节点有没有访问过的陆地就把它们加入队列然后标记

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; // 只要加入队列立刻标记
            }
        }
    }
}

100. 岛屿的最大面积

这一题是求所有岛屿中最大的岛屿面积

dfs

我们就用一个count记录当前岛屿的面积然后每当我们在主函数遇到一个没有访问过的陆地我们就归零count然后进入dfs深搜在dfs逻辑里面标记一个地点就count++

int count;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
    if (visited[x][y] || grid[x][y] == 0) return; // 终止条件：访问过的节点 或者 遇到海水
    visited[x][y] = true; // 标记访问过
    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;  // 越界了，直接跳过
        dfs(grid, visited, nextx, nexty);
    }
}

bfs

同dfs一样的思路代码不一样创建队列的时候可以用pair 也可以分别把x，y都放进队列里

int count;
    int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
    void bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
        queue<int> que;
        que.push(x);
        que.push(y);
        visited[x][y] = true; // 加入队列就意味节点是陆地可到达的点
        count++;
        while(!que.empty()) {
            int xx = que.front();que.pop();
            int yy = que.front();que.pop();
            for (int i = 0 ;i < 4; i++) {
                int nextx = xx + dir[i][0];
                int nexty = yy + dir[i][1];
                if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 越界
                if (!visited[nextx][nexty] && grid[nextx][nexty] == 1) { // 节点没有被访问过且是陆地
                    visited[nextx][nexty] = true;
                    count++;
                    que.push(nextx);
                    que.push(nexty);
                }
            }
        }
    }

101. 孤岛的总面积

本题是求孤岛的总面积孤岛就是陆地不接触边缘的岛屿我们可以用一个思路从四个边缘开始搜索只要遇到陆地就把它变成水域最后剩下的岛屿就是孤岛

dfs

优化：如果四个方向中有水域就不用继续深搜下去

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

bfs

int count = 0;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
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; // 只要加入队列立刻标记
            }
        }
    }
}

102. 沉没孤岛

本题要求我们把孤岛变成0 其实这一题和上一题求孤岛思路差不多我们同样是先从边缘开始搜索遇到陆地我们可以赋值为2 然后最后两层for'循环将2赋值成1 将剩下的孤岛1赋值成0

#include <iostream>
#include <vector>
using namespace std;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向
void dfs(vector<vector<int>>& grid, int x, int y) {
    grid[x][y] = 2;
    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 || grid[nextx][nexty] == 2) 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);
    }
    // 步骤二、步骤三
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 1) grid[i][j] = 0;
            if (grid[i][j] == 2) grid[i][j] = 1;
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << grid[i][j] << " ";
        }
        cout << endl;
    }
}

原文地址：https://blog.csdn.net/m0_73740071/article/details/142468414

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：数据科学基石：解析属性类型体系——从标称到比率，全面洞察数据分类机制
下一篇：机器学习中分类问题的各类评估指标总结

XSS闯关小游戏（前13关）
1.存在可控参数2.页面存在回显3.使用带有特殊字符的语句去测试，网站是否进行了实例化 ( 例如 '">123 )4.构造闭合，实现payload的逃逸。
阅读更多2024-09-24
CSS的弹性盒子模型（Flex box)
弹性盒子模型是CSS3的一种新的布局模式，弹性盒是一种当页面需要适应不同的屏幕大小以及设备类型时确保拥有合适的布局方式，引入弹性盒子模型的目的时提供更加有效的方式来对一个容器中的子元素进行排列，对齐和
阅读更多2024-09-24
【已解决】使用JAVA语言实现递归调用-本关任务：用循环和递归算法求 n（小于 10 的正整数）的阶乘 n!。
本关任务：用循环和递归算法求 n（小于 10 的正整数）的阶乘 n!。测试说明平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：测试输入：10预期输
阅读更多2024-09-24
【Python】基于python实现Windows Service程序
最近揽了一个小活，就是基于Python设计一个Windows Service程序，和一般应用不同的是，Service直接运行在后台，不会在运行时弹出黑框，因此在设计上和一般的程序有些微差别。因为之前从
阅读更多2024-09-24
golang学习笔记11-模块化与包管理【重要】
在第六节（golang学习笔记6）中，我讲了如何自定义包，包其实有两种引用方式，一种是不用模块，还有种是用模块，我用的就是后者。尚硅谷的视频（见本专栏简介）是不用模块的，但这其实是旧版本的做法，本节再
阅读更多2024-09-24
黑马头条day3-2 自媒体文章管理
前边还有一个素材列表查询没什么难度就略过了查询所有频道和查询自媒体文章也是和素材列表查询类似就是普通的查询所以略过了。
阅读更多2024-09-24
Java Alibaba Druid 数据库连接池
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的
阅读更多2024-09-24
【数据结构】对象的比较
Java对象的比较，掌握使用Comparable、Comparator接口
阅读更多2024-09-24
JavaScript引入到文件的三种方式
首先命名一个由.js为后缀的文件，然后在HTML文件中使用Script标签中的src属性引入。利用script标签，将js文件引入到HTML文件中。使用Script标签中的src属性引入网页地址。
阅读更多2024-09-24
力扣周赛 —— 416
只做出了第一道，第二第三道都超时。痛，太痛了。
阅读更多2024-09-24