day-62 代码随想录算法训练营（19）图论 part 01

最新推荐文章于 2024-10-18 23:40:34 发布
最新推荐文章于 2024-10-18 23:40:34 发布
阅读量832 收藏
点赞数
分类专栏： # 代码随想录算法训练营（19） 文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ricardo_XIAOHAO/article/details/133410714
版权

797.所有可能的路径

分析：从 0~n-1的所有可能的路径
思路一：回溯
  • 使用中间数组mid，添加起始位置 0 ，然后遍历二维数组
  • 遍历到一维时，下一轮递归直接跳入当前值所代表下标的数组中
  • 终止条件：mid的结尾值为 n-1 时 或者 遍历到的数组下标等于 n 时
class Solution {
public:
    vector<vector<int>>res;
    vector<int>mid={0};
    void backtrace(vector<vector<int>>&graph,int starti,int n){
        if(mid.back()==n-1){//遍历到一条路径时
            res.push_back(mid);
            return;
        }
        if(starti==n) return;//超出二维下标
        for(int i=0;i<graph[starti].size();i++){
            mid.push_back(graph[starti][i]);
            backtrace(graph,graph[starti][i],n);
            mid.pop_back();//回溯
        }
    }
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        int n=graph.size();
        backtrace(graph,0,n);
        return res;
        
    }
};

200.岛屿数量

思路一：深度优先遍历
  • 1.遍历所有位置
  • 2.遍历到没有访问过的岛屿时，res自增，并对它四个方向进行深度优先遍历
class Solution {
public:
    int direct[4][2]={{0,1},{0,-1},{-1,0},{1,0}};
    void dfs(vector<vector<char>>&grid,vector<vector<bool>>&visted,int x,int y){
        for(int i=0;i<4;i++){//从四个方向进行深度优先搜索
            int nextx = x+direct[i][0];
            int nexty = y+direct[i][1];
            if(nextx<grid.size() && nextx>=0 && nexty<grid[0].size() && nexty>=0){//当未越界时
                if(grid[nextx][nexty]=='1' && !visted[nextx][nexty]){//当前陆地没有被遍历过时
                    visted[nextx][nexty]=true;
                    dfs(grid,visted,nextx,nexty);
                }
            }
        }
        
    }
    int numIslands(vector<vector<char>>& grid) {
        int n=grid.size(),m=grid[0].size();
        int res=0;
        vector<vector<bool>>visted(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){//对所有位置进行遍历
            for(int j=0;j<m;j++){
                if(grid[i][j]=='1' && !visted[i][j]){//当前陆地没有被遍历过时
                    visted[i][j]=true;
                    res++;
                    dfs(grid,visted,i,j);//遍历连接的陆地
                }
            }
        }
        return res;
    }
};
思路二：广度优先遍历
  • 1.首先遍历所有位置
  • 2.遇到没有遍历到的陆地，res 自增，并且进入广度优先遍历
  • 3.广度优先遍历：把遍历到的坐标标记后，直接放入栈中，然后在栈中一层一层的进行遍历
class Solution {
public:
    int direct[4][2]={{0,1},{0,-1},{-1,0},{1,0}};
    void bfs(vector<vector<char>>&grid,vector<vector<bool>>&visted,int x,int y){
        queue<pair<int,int>>que;
        que.push(make_pair(x,y));
        visted[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+direct[i][0];
                int nexty=cury+direct[i][1];
                //防止越界
                if(nextx>=0 && nextx<grid.size() && nexty>=0 && nexty<grid[0].size()){
                    if(grid[nextx][nexty]=='1' && !visted[nextx][nexty]){
                        que.push(make_pair(nextx,nexty));//放入当前层，下次遍历下一层
                        visted[nextx][nexty]=true;
                    }
                }
            }
            
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        int n=grid.size(),m=grid[0].size();
        int res=0;
        vector<vector<bool>>visted(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){//对所有位置进行遍历
            for(int j=0;j<m;j++){
                if(grid[i][j]=='1' && !visted[i][j]){//当前陆地没有被遍历过时
                    visted[i][j]=true;
                    res++;
                    bfs(grid,visted,i,j);//遍历连接的陆地
                }
            }
        }
        return res;
    }
};

695.岛屿的最大面积

思路一：广度优先搜索
  • 1.遍历所有位置
  • 2.当前位置为陆地并且没有被遍历过时，进入广度优先遍历
  • 3.广度优先遍历：每次遍历到一块新的陆地时，mid 自增，最后返回mid
  • 4.通过 mid 更新最大面积
class Solution {
public:
    int direct[4][2]={{0,1},{0,-1},{-1,0},{1,0}};
    int bfs(vector<vector<int>>&grid,vector<vector<bool>>&visted,int x,int y){
        queue<pair<int,int>>que;
        que.push(make_pair(x,y));
        visted[x][y]=true;
        int mid=1;//初始只有一个岛屿
        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+direct[i][0];
                int nexty=cury+direct[i][1];
                if(nextx>=0 && nextx<grid.size() && nexty>=0 && nexty<grid[0].size()){
                    if(!visted[nextx][nexty] && grid[nextx][nexty]==1){
                        mid++;//遍历到新的陆地面积自增
                        que.push(make_pair(nextx,nexty));
                        visted[nextx][nexty]=true;
                    }
                }
            }
        }
        return mid;
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int n=grid.size(),m=grid[0].size();
        vector<vector<bool>>visted(n,vector<bool>(m,false));
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(!visted[i][j] && grid[i][j]==1){
                    int mid=bfs(grid,visted,i,j);//获取当前岛屿面积
                    if(mid>res) res=mid;//更新最大面积
                }
            }
        }
        return res;
    }
};

 

思路二：深度优先遍历
  • 1.遍历所有元素
  • 2.遍历到新的陆地时，先标记访问过，再进入深度优先遍历
  • 3.往四个方向进行遍历，遍历到新的陆地时计数自增
  • 4.深度优先搜索结束时，更新最大面积（更新完后注意计数值赋值为1）
class Solution {
public:
    int direct[4][2]={{0,1},{0,-1},{-1,0},{1,0}};
    int res=0;
    int mid=1;
    void dfs(vector<vector<int>>&grid,vector<vector<bool>>&visted,int x,int y){
        for(int i=0;i<4;i++){
            int nextx=x+direct[i][0];
            int nexty=y+direct[i][1];
            //越界控制
            if(nextx>=0 && nextx<grid.size() && nexty>=0 && nexty<grid[0].size()){
                if(!visted[nextx][nexty] && grid[nextx][nexty]==1){//遍历到新的陆地时
                    visted[nextx][nexty]=true;
                    mid++;//面积自增
                    dfs(grid,visted,nextx,nexty);//进入深度优先搜索
                }
            }
        }
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int n=grid.size(),m=grid[0].size();
        vector<vector<bool>>visted(n,vector<bool>(m,false));
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(!visted[i][j] && grid[i][j]==1){
                    visted[i][j]=true;
                    dfs(grid,visted,i,j);//进入深度优先搜索
                    if(mid>res) res=mid;
                    mid=1;//记录面积值重新赋值
                }
            }
        }
        return res;
    }
};

djykkkkkk
关注
专栏目录
代码随想录算法训练营Day8
weixin_44520607的博客
12-02 612
代码随想录算法训练营Day8
day-64 代码随想录算法训练营（19）图论 part 03
Ricardo的博客
10-02 436
827.最大人工岛 127.单词接龙 841.钥匙和房间
day-65 代码随想录算法训练营（19）图论 part 04
Ricardo的博客
10-05 719
463.岛屿的周长 1971.寻找图中是否存在路径 684.冗余连接 685.冗余连接 ||
day-63 代码随想录算法训练营（19） 图论 part 02
Ricardo的博客
10-01 655
1020.飞地的数量 130.被围绕的区域 417.太平洋大西洋流水问题
代码随想录算法训练营Day50||图论part01
DetouringSnail的博客
07-26 184
卡玛网98.所有可达到路径：和力扣797.所有可能的路径一致。邻接表和邻接矩阵的写法都要掌握。先写了一遍邻接矩阵写法，算是先熟悉了一下代码。先熟悉一些图论基础，以及搜索理论基础。深度优先搜索理论基础类似于回溯算法（递归法），广度优先搜索就类似于迭代法。深度搜索三部曲也和回溯算法类似。昨天的题补完啦~最后熟悉了一下单调栈。今天开始没视频看了，只能啃文字了。
代码随想录算法训练营Day62|| 图论part11
DetouringSnail的博客
08-07 190
算是一刷结束了，图论纯走马观花，晚点写个小总结吧。Floyd 算法和Astar算法。
代码随想录算法训练营Day54|| 图论part04
DetouringSnail的博客
07-30 286
算是一题简单的基础题，可以用来巩固邻接表的写法。从节点1开始，把所有能访问到的节点全都标记为true，继续深度搜索。卡玛网106岛屿的周长：这题即不需要深搜，也不需要广搜，题中给出了只有一个岛屿，从陆地的点开始朝四个方向走，遇到水了就说明有一条边，遍历所有的陆地，计算遇到水的次数即可。思路二是计算相邻岛屿的数量来计算边数。卡玛网110字符串接龙：相当于求无向图的最短路径，广搜最合适，因为广搜第一次找到路径一定最短。广搜就要利用队列，代码是能看懂的。能理解就很花时间了，先看懂逻辑和代码，关键基础部分写写吧。
代码随想录算法训练营Day59 || 图论part 09
DetouringSnail的博客
08-05 196
Bellman_ford算法精讲，卡玛网94题：变化在于权值出现了负数，用动态规划思想来维护MinDist数组。核心在于对所有边进行n-1次松弛处理，就可以得出起始点到所有节点的最短路径。dijkstra算法（堆优化版）：利用小顶堆来减少一层for循环。因为要存储边的权值，邻接表里就需要存pair了。图论章节主打一个走马观花属于是。
代码随想录算法训练营Day57|| 图论part06
DetouringSnail的博客
08-02 217
Prim算法，卡玛网53寻宝：最小生成数的prim算法三部曲。不要不断维护minDist数组，不断遍历该数组，把离树最近的点加入树。记录边的时候有特殊的技巧。kruskal算法：看思路的时候就想到的并查集来判断两点是否在同一个集合。先把边按照val排序，之后判断是否要加入树。代码都能看懂，自己写肯定还是困难。
代码随想录算法训练营Day55|| 图论part05
DetouringSnail的博客
07-31 174
寻找存在的路径：就是并查集的基础应用题，source和destination的根一致则表示有路径。注意，这是个无向图。注意要理解每个函数，尤其是路径压缩的内容，其实不难，但是需要时间消化。建议理解后直接背板。
代码随想录算法训练营day1
weixin_44520607的博客
11-16 1370
代码随想录 算法训练营第一天
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 633
代码随想录-035期-算法训练营【博客笔记汇总表】
【代码随想录训练营】Day2-数组
weixin_38255385的博客
10-13 4367
代码随想录训练营Day2，欢迎大家一起交流！
【代码随想录训练营】Day7-哈希表
weixin_38255385的博客
10-18 3209
代码随想录第7天
【算法】双指针
2303_80828380的博客
10-13 764
力扣oj题之双指针算法
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1190
例如，当输入 (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。
力扣10.13
qq_40052678的博客
10-13 423
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
PMRF：一种新的图像恢复算法 高质量修复图像 降低图像失真还原跟自然逼真度
GDL_MPY的博客
10-14 1007
（Posterior-Mean Rectified Flow，后验均值修正流）是一种新提出的图像恢复算法，旨在解决图像恢复任务中的。在去噪、超分辨率、修复等不同图像恢复任务中，PMRF能够在多个图像质量评估指标（如PSNR、SSIM、FID等）上表现出色，且没有明显的弱点，展示了其在多任务环境下的稳健性。图像恢复任务（如去噪、超分辨率、盲恢复等）中，常常需要在（如均方误差MSE）和（如图像的真实感和自然度，使用FID、SSIM等衡量）之间做权衡。
19.面试算法-树的深度优先遍(一)
最新发布
weixin_36401695的博客
10-18 217
面试算法-树的深度优先遍历
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值