【图论算法题记录】广搜/深搜题目汇总

已于 2024-08-13 15:44:41 修改
阅读量395 收藏 7
点赞数 5
分类专栏： 算法 文章标签： 算法 图论 深度优先 广度优先
于 2024-07-07 11:37:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43627638/article/details/140243749
版权

目录

岛屿问题

岛屿数量

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

cpp-BFS

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N = 50;
#define pi pair<int, int>
int grid[N][N];
int dir[4][2] = { -1, 0, 1, 0, 0, -1, 0, 1 };
 
 
int main() {
    int n, m;   // 行数，列数
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
 
    vector<vector<int>> visited(n, vector<int>(m, 0));  // 设置访问数组
    int cnt = 0;
     for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (visited[i][j] == 0 && grid[i][j] == 1) {
                cnt++;
                queue<pi> q;
                q.push(pi(i, j)); visited[i][j] = 1;    // 首先访问(0, 0)
                while (!q.empty()) {
                    pi cur = q.front(); q.pop();
                    int curx = cur.first;
                    int cury = cur.second;
                    for (int k = 0; k < 4; k++) {
                        int x = curx + dir[k][0];
                        int y = cury + dir[k][1];
                        if (x < 0 || x >= n || y < 0 || y >= m) continue; // 超出索引范围就continue
                        if (visited[x][y] == 0 && grid[x][y] == 1) {
                            visited[x][y] = 1;
                            q.push(pi(x, y));
                        }
                    }
                }
            }
        }
    }
    cout << cnt << endl;
    return 0;
}

cpp-DFS

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N = 50;
#define pi pair<int, int>
int n, m;   // 行数，列数
vector<vector<int>> grid(N, vector<int>(N, 0));
int dir[4][2] = { -1, 0, 1, 0, 0, -1, 0, 1 };
 
void dfs(int curx, int cury, vector<vector<int>>& grid, vector<vector<int>>& visited){
    for(int i = 0; i < 4; i++){
        int x = curx + dir[i][0];
        int y = cury + dir[i][1];
        if(x < 0 || x >= n || y < 0 || y >= m) continue;
        if(visited[x][y] == 0 && grid[x][y] == 1){
            visited[x][y] = 1;
            dfs(x, y, grid, visited);
        }
    }
}
 
int main() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> grid[i][j];
        }
    }
 
    vector<vector<int>> visited(n, vector<int>(m, 0));  // 设置访问数组
    int cnt = 0;
     for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (visited[i][j] == 0 && grid[i][j] == 1) {
                visited[i][j] = 1;
                cnt++;
                dfs(i, j, grid, visited);
            }
        }
    }
    cout << cnt << endl;
    return 0;
}

岛屿的最大面积

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

cpp-BFS

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define pi pair<int, int>
int n, m;   // 行数，列数
int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1}; // 上下左右四个方向
 
void bfs(int i, int j, vector<vector<int>>& grid, vector<vector<int>>& visited, int& cur_size){
    queue<pi> q;
    q.push(pi(i, j)); visited[i][j] = 1; // 将(i, j)入队，且设为已访问过
    while(!q.empty()){
        pi cur = q.front(); q.pop();
        int curx = cur.first;
        int cury = cur.second;
        for(int k = 0; k < 4; k++){
            int x = curx + dir[k][0];
            int y = cury + dir[k][1];
            if(x < 0 || x >= n || y < 0 || y >= m) continue;  // 如果超出索引范围则continue
            if(visited[x][y] == 0 && grid[x][y] == 1){
                q.push(pi(x, y));   // 让当前陆地入队
                visited[x][y] = 1;
                cur_size++;
            }
        }
    }
}
 
int main(){
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m));
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> grid[i][j];
        }
    }
     
    int max_size = 0;
    vector<vector<int>> visited(n, vector<int>(m, 0));  // 访问数组
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            int cur_size = 0;
            if(visited[i][j] == 0 && grid[i][j] == 1){  // 如果当前是没有访问过的陆地才进行下面语句
                cur_size++; // 记录当前面积
                bfs(i, j, grid, visited, cur_size);
                max_size = max(max_size, cur_size);
            }
        }
    }
    cout << max_size << endl;
    return 0;
}

孤岛的总面积

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

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

cpp-BFS

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define pi pair<int, int>
int n, m;   // 行数，列数
int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1}; // 上下左右四个方向
int island_size = 0;
 
void bfs(int i, int j, vector<vector<int>>& grid){
    queue<pi> q;
    q.push(pi(i, j)); grid[i][j] = 0; // 将(i, j)入队，且设为已访问过
    island_size++;
    while(!q.empty()){
        pi cur = q.front(); q.pop();
        int curx = cur.first;
        int cury = cur.second;
        for(int k = 0; k < 4; k++){
            int x = curx + dir[k][0];
            int y = cury + dir[k][1];
            if(x < 0 || x >= n || y < 0 || y >= m) continue;  // 如果超出索引范围则continue
            if(grid[x][y] == 1){
                q.push(pi(x, y));   // 让当前陆地入队
                grid[x][y] = 0;
                island_size++;
            }
        }
    }
}
 
int main(){
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m));
    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(i, 0, grid);
        if(grid[i][m-1] == 1) bfs(i, m-1, grid);
    }
     
    for(int j = 0; j < m; j++){
        if(grid[0][j] == 1) bfs(0, j, grid);
        if(grid[n-1][j] == 1) bfs(n-1, j, grid);
    }
     
    island_size = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] == 1){  // 如果当前是没有访问过的陆地才进行下面语句
                bfs(i, j, grid);
            }
        }
    }
    cout << island_size << endl;
    return 0;
}

沉没孤岛

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

现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。

cpp-BFS

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define pi pair<int, int>
int n, m;   // 行数，列数
int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1}; // 上下左右四个方向
int island_size = 0;
  
void bfs(int i, int j, vector<vector<int>>& grid, int flag){
    queue<pi> q;
    q.push(pi(i, j)); grid[i][j] = flag; // 将(i, j)入队，且设为已访问过
    while(!q.empty()){
        pi cur = q.front(); q.pop();
        int curx = cur.first;
        int cury = cur.second;
        for(int k = 0; k < 4; k++){
            int x = curx + dir[k][0];
            int y = cury + dir[k][1];
            if(x < 0 || x >= n || y < 0 || y >= m) continue;  // 如果超出索引范围则continue
            if(grid[x][y] == 1){
                q.push(pi(x, y));   // 让当前陆地入队
                grid[x][y] = flag;
            }
        }
    }
}
  
int main(){
    cin >> n >> m;
    vector<vector<int>> grid(n, vector<int>(m));
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> grid[i][j];
        }
    }
     
    int flag = 2;   // 标记周边岛屿为2
    for(int i = 0; i < n; i++){ // 从左边和右边向中间遍历
        if(grid[i][0] == 1) bfs(i, 0, grid, flag);
        if(grid[i][m-1] == 1) bfs(i, m-1, grid, flag);
    }
      
    for(int j = 0; j < m; j++){
        if(grid[0][j] == 1) bfs(0, j, grid, flag);
        if(grid[n-1][j] == 1) bfs(n-1, j, grid, flag);
    }
      
    flag = 0;   // 标记孤岛为0
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] == 1){  // 如果当前是没有访问过的陆地才进行下面语句
                bfs(i, j, grid, flag);
            }
        }
    }
 
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(grid[i][j] == 2) grid[i][j] = 1;
            if(j != 0) cout << " " << grid[i][j];
            else cout << grid[i][j];
        }
        cout << endl;
    }
    return 0;
}

最短路径问题

迷宫之城-4399笔试题

在一个名为“迷宫之城”的冒险游戏中，玩家需要控制角色穿越一个复杂多变的迷宫，以找到出口并逃脱。

给定一个迷宫的二维网格表示，其中：

  1. 网格中的每个单元格可以是空地(用0表示)、墙壁(用'1'表示)、起点(用'S'表示，且只有一个)、终点(用E表示，且只有一个)。
  2. 玩家可以从一个空地移动到相邻的四个方向(上、下、左、右)的空地，但不能穿过墙壁。
  3. 迷宫中可能存在单向门，用特殊字符(如'D'表示向下可通行的单向门，'U'表示向上可通行的单向门，'L'和'R'分别表示左右)标记在空地单元格上。这些单向门仅允许玩家按照指示方向移动，反方向则视为墙壁。

请设计一个算法，找出从起点到终点的最短路径，并返回该路径的长度(以步数计)。如果不存在路径，则返回-1。

【输入格式】 输入为一个二维字符数组maze，表示迷宫的布局。
【输出格式】 输出一个整数，表示从起点到终点的最短路径长度(含起点)。如果不存在路径，则输出-1。
【提示】 迷宫的大小不会超过100x100迷言中只包含一个起点和一个终点。 请用C++解决。

【示例输入】

[
	['S', '0', '0', '0'],
	['0', '1', 'D', '0'],
	['0', '0', '0', 'E'],
	['0', 'U', '0', '0']
]

【示例输出】

6

cpp-BFS

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define pi pair<int, int>

// bfs实现
int findPath(const vector<vector<char>>& maze){
    int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1}; // 上下左右四个方向
    char onedir[4] = {'U', 'D', 'L', 'R'};  // 单向门的方向
    int n = maze.size();    // 迷宫的行
    int m = maze[0].size(); // 迷宫的列
    vector<vector<int>> visited(n, vector<int>(m, 0));   // 初始化访问数组
    
    // 找起点和终点
    int sX = -1, sY = -1;
    int eX = -1, eY = -1;
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < m; ++j){
            if(maze[i][j] == 'S'){
                sX = i; sY = j;
            }
            if(maze[i][j] == 'E'){
                eX = i; eY = j;
            }
        }
    }
    
    queue<pi> q;
    q.push(pi(sX, sY));   // 先将起点加入队列
    visited[sX][sY] = 1;
    int steps = 0;
    
    while(!q.empty()){
        int qSize = q.size();
        for(int i = 0; i < qSize; ++i){
            pi cur = q.front(); q.pop();
            int curX = cur.first;
            int curY = cur.second;

            // 判断是否已经到了终点
            if(curX == eX && curY == eY){
                return steps;
            }

            // 分别判断上下左右四个方向的情况
            for(int j = 0; j < 4; ++j){
                int nextX = curX + dir[j][0];
                int nextY = curY + dir[j][1];
                if(nextX < 0 || nextX >= n || nextY < 0 || nextY >= m || visited[nextX][nextY] == 1){
                    continue;
                }
                // 判断当前方格是否是空地/终点/对应方向的传送门
                if(maze[nextX][nextY] == '0' || maze[nextX][nextY] == 'E' 
                        || maze[nextX][nextY] == onedir[j]){
                    q.push(pi(nextX, nextY));
                    visited[nextX][nextY] = 1;
                }
            }
        }
        steps++; // 完成一层后，步数加1
    }
    return -1; // 如果没有路径
}

int main(){
    vector<vector<char>> maze = {
        {'S', '0', '0', '0'},
        {'0', '1', 'D', '0'},
        {'0', '0', '0', 'E'},
        {'0', 'U', '0', '0'}
    };
    int ans = findPath(maze);
    cout << ans << endl;
}
一米八五羊毛菌
关注
专栏目录
蓝桥杯图论算法知识和真题讲解
08-22
图论重要算法: 如下是大致目录 1. 图的表示 2. 图的遍历 3. DFS/BFS用于连通性判断 4. BFS用于所有边等长时求最短路径 5. 并查集：维护连通性 6. 最短路径 7. 最小生成树 8. 查询树上两个点的距离 9. 真题解析 10. ...
【算法面试题汇总】LeetBook列表的算法面试题汇总---图论题目及答案
m0_57293204的博客
12-05 364
单词接龙 岛屿数量 课程表 课程表Ⅱ
算法编程题 排序、搜索、图论、动态规划
09-06
以下是一些常见的算法编程题，涵盖了排序、搜索、图论、动态规划等领域： 排序算法 冒泡排序（Bubble Sort） 选择排序（Selection Sort） 插入排序（Insertion Sort） 快速排序（Quick Sort） 归并排序（Merge Sort...
图论算法软件Graph.exe
02-03
Graph.exe是一个图论算法软件，用于执行各种图论算法。它可以用来解决图论问题，如最短路径、最小生成树、网络流等。用户可以输入图的结构和权重，然后选择所需的算法进行计算，最后得到相应的结果。该软件可以帮助...
龚劬《图论与网络最优化算法》课后习题及参考答案
01-04
《图论与网络最优化算法》是计算机科学与工程领域中的一门重要课程，主要研究如何在图结构中寻找最优解。龚劬教授的这本教材深入浅出地讲解了图论的基本概念、网络最优化算法及其应用。课后习题和参考答案是学习过程...
main-7.rar_图论算法_深度搜索
09-21
图论是计算机科学中一个非常重要的分支，它研究的是图形结构以及其中的节点和边的关系。在图论中，寻找最短路径问题是一项常见的任务，这在很多实际应用中都有所体现，比如网络路由、交通规划等。深度优先搜索（DFS...
二叉树系列 10/11
2301_78191305的博客
10-11 428
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 249
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 201
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 385
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 374
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1162
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 1009
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
数据结构与算法——Java实现 32.堆
m0_73983707的博客
10-10 438
如果权值大于最末尾元素，则不断上调与其（最末尾元素，不断更新）父元素比较，直到找到小于堆中某元素的值或更新到堆顶元素。每个节点的总高度除以结点所在每一层的高度 *（高度-1）之和。有关，高度从下往上依次相加，交换次数为h-1，总交换次数为。大顶堆每个分支的上一个节点的权值要大于它的孩子节点。小顶堆每个分支的上一个节点的权值要小于它的孩子节点。不断的向堆中添加节点，添加时与堆最末尾元素进行比较。Floyd建堆算法的时间复杂度为O(n)时间复杂度为O(n*logn)（与其左右孩子节点中的。
算法：双指针系列（二）——对撞指针
2301_81454749的博客
10-09 779
分享有趣的题目，算法技巧
力扣hot100--二叉树
qq_73450329的博客
10-14 435
给定一个二叉树的根节点。
P1320压缩技术（续集版
m0_73562697的博客
10-10 247
我参考了一写题解自己又写了自己的解法，vs中的scanf_s和scanf()用法不太一样，之前按scanf写法写一直在报错，心态有点被搞崩了。感觉这题还是蛮难的对我来说，通过这题我才知道原来字符串输入不碰到空格就会一起输进来。突然想起来就是还有一个坑就是如果最后一位是0就不用输出了。
24/10/13 算法笔记 GoogLeNet
yyyy2711的博客
10-13 752
自定义卷积层的时候：创建一个具有特殊行为的卷积层，比如改变卷积核的大小，步长，填充或者添加特定的激活函数组合时，需要继承现有的层并重写forward函数。实现特殊模型时：如Inception网络，ResNet等，其中包含了多个并行的卷积路径，需要在forward函数中实现这些路径的数据流动。第二层：第一个卷积层64个通道，1*1卷积层，第二个卷积层使用将通道数量增加三倍的3*3卷积层，这对于inception块中的第二条路径。使用最大汇聚层，在空间上降低特征图的尺寸，同时保留最重要的信息。
24/10/12 算法笔记 汇聚层
yyyy2711的博客
10-12 294
在卷积神经网络（CNN）中，卷积层对空间降采样具有一定的敏感性，这意味着卷积层对输入数据的空间位置变化比较敏感。这种敏感性在某些情况下是有益的，因为它允许网络捕捉到精确的特征位置，但在其他情况下，我们可能希望网络对输入的微小变化更加鲁棒。在处理多通道输入数据时，汇聚层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总。这意味着汇聚层的输出通道数与输入通道数相同。（pooling）层等于池化层，它具有双重目的：降低卷积层对位置的敏感性，同时降低对空间降采样表示的敏感性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值