leetcode图论基础入门

已于 2022-03-12 04:22:46 修改
阅读量395 收藏 1
点赞数
分类专栏： # leetcode 刷 文章标签： 图论 leetcode 深度优先
于 2022-03-10 23:31:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50956208/article/details/123414157
版权

文章目录

leetcode 14天图论基础

day : 1

733. 图像渲染

思路：dfs,需要注意的是：如果newColor = 中心点的数值，不能dfs，不然就会一直递归，此时，可知不需要改变，直接将原数组返回就行

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        int aim = image[sr][sc];
        int m = image.length, n = image[0].length;
        if(aim == newColor) ;	//key, 不然会一直递归，栈溢出:java.lang.StackOverflowError
        else
            dfs(image, sr, sc, aim, m, n, newColor);
        return image;
    }

    public void dfs(int[][] image, int x, int y, int aim, int m, int n, int newColor){
        if(x < 0 || y < 0 || x >= m || y >= n || image[x][y] != aim)
            return;
        image[x][y] = newColor;
        dfs(image, x, y - 1, aim, m, n, newColor); //上
        dfs(image, x, y + 1, aim, m, n, newColor); //下
        dfs(image, x - 1, y, aim, m, n, newColor); //左
        dfs(image, x + 1, y, aim, m, n, newColor); //右
    }
}

200. 岛屿数量

思路: dfs,分别以每个点为中心进行遍历，如果中心点为1，则此处必然有一个岛，一直四个方向dfs，并在遍历过程中将每个1都置为0，以防重复，直到找到所以边界点，则一个岛便找到了
在这里插入图片描述

version 1.0
class Solution {
boolean isLandsFlag = false;	//用一个flag来标记找到1，也就是这里有一个岛

    public int numIslands(char[][] grid) {
        int m = grid.length, n = grid[0].length;
        int ans = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                dfs(grid, i, j, m, n);
                if(isLandsFlag)
                    ans++;
                isLandsFlag = false;//恢复
            }
        }
        return ans;
    }
    
    public void dfs(char[][] grid, int x, int y, int m, int n){
        if(x < 0 || x >= m || y < 0 || y >= n || grid[x][y] == '0')
            return;
        grid[x][y] = '0';
        isLandsFlag = true;
        dfs(grid, x - 1, y, m, n);
        dfs(grid, x + 1, y, m, n);
        dfs(grid, x, y - 1, m, n);
        dfs(grid, x, y + 1, m, n);
    }
}
version 2.0
//仅仅将m,n换为数组.length,以减少递归函数的变量个数，但是效果却变差了
class Solution {
boolean isLandsFlag = false;

    public int numIslands(char[][] grid) {
        int ans = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                dfs(grid, i, j);
                if(isLandsFlag)
                    ans++;
                isLandsFlag = false;
            }
        }
        return ans;
    }
    
    public void dfs(char[][] grid, int x, int y){
        if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == '0')
            return;
        grid[x][y] = '0';
        isLandsFlag = true; //一旦有陆地，那这片必然有岛屿
        dfs(grid, x - 1, y);
        dfs(grid, x + 1, y);
        dfs(grid, x, y - 1);
        dfs(grid, x, y + 1);
    }
}

由上面可知将数组大小用变量存着速度更快, 终极版如下

version 3.0
class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length, n = grid[0].length;
        int ans = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                //找到1才进行调用dfs
                if(grid[i][j] == '1'){
                    dfs(grid, i, j, m, n);
                    ans++;
                }
            }
        }
        return ans;
    }
    
    public void dfs(char[][] grid, int x, int y, int m, int n){
        if(x < 0 || x >= m || y < 0 || y >= n || grid[x][y] == '0')
            return;
        grid[x][y] = '0';
        dfs(grid, x - 1, y, m, n);
        dfs(grid, x + 1, y, m, n);
        dfs(grid, x, y - 1, m, n);
        dfs(grid, x, y + 1, m, n);
    }
}

day : 2

695. Max Area of Island

在这里插入图片描述

思路：dfs， 找到土地，则必有岛，对遇到的每块土地记录，并置0，最后一直取最值，即可

class Solution {
private int ans = 0;
    public int maxAreaOfIsland(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int maxans = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 1){
                    dfs(grid, i, j, m, n);
                    maxans = Math.max(maxans, ans);
                    ans = 0;
                }
            }
        return maxans;
    }

    public void dfs(int[][] grid, int i, int j, int m, int n){
        if(i < 0 || j < 0 || i >= m || j >= n || grid[i][j] == 0)
            return;
        grid[i][j] = 0;
        ans++;
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i, j - 1, m, n);
        dfs(grid, i, j + 1, m, n);
    }
}

1254. 统计封闭岛屿的数目

在这里插入图片描述

思路: 此题与前面不同在于，并没有说矩阵四周布满了水，而且水为1，土地为0，所以岛屿只可能在中间区域，不会在边缘，在dfs过程中，如果探出了边界，就要把flag置flase, 表示虽然回溯了，但是这不是一个封闭岛屿。

class Solution {
private boolean flag;
    public int closedIsland(int[][] grid) {
        int ans = 0;
        int m = grid.length, n = grid[0].length;
        flag = true;
        for(int i = 1; i < m - 1; i++){
            for(int j = 1; j < n - 1; j++){
                if(grid[i][j] == 0){
                   dfs(grid, i, j, m, n);
                   if(flag) ans++;
                   flag = true; 
                }
            }
        }
        return ans;
    }

    public void dfs(int[][] grid, int i, int j, int m, int n){
        if(i < 0 || j < 0 || i >= m || j >= n){
            flag = false;
            return;
        }
        if(grid[i][j] == 1) //遇水返回
            return;
        grid[i][j] = 1;
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i, j - 1, m, n);
        dfs(grid, i, j + 1, m, n);
    }
}

day : 3

1020. 飞地的数量

image-20220312030811349

思路1：

dfs, 用一个flag来标记是否是岛屿，一旦越界则表示可以走通，置flase,遇到0就返回，定一个成员变量cnt，遇到1就++，

并把1置为0，表示已经走过了，如果是岛屿就把ans 加 cnt,否则cnt清零

class Solution {
boolean isIsand;
int cnt;
    public int numEnclaves(int[][] grid) {
        int ans = 0;
        isIsand = true;
        cnt = 0;
        int m = grid.length, n = grid[0].length;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 1){
                    dfs(grid, i, j, m, n);
                    if(isIsand) ans += cnt;
                    cnt = 0;
                    isIsand = true;
                }
            }
        }
        return ans;
    }

    public void dfs(int[][] grid, int i, int j, int m, int n){
        if(i < 0 || j < 0 || i >= m || j >= n){//越界
            isIsand = false;
            return;
        }
        if(grid[i][j] == 0)
            return;
        if(grid[i][j] == 1)
            cnt++;
        grid[i][j] = 0;
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i, j - 1, m, n);
        dfs(grid, i, j + 1, m, n);
    }
}
思路2：

image-20220312032428990

一块土地能走出去就不计数，故，可以对边界先进行dfs，将所有能出去的全部清零，最后遍历剩余数组，遇到1就ans++即可,因为剩余的一定都走不出去

class Solution {
    public int numEnclaves(int[][] grid) {
        int ans = 0;
        int m = grid.length, n = grid[0].length;
        for(int i = 0; i < m; i++){
            dfs(grid, i, 0, m, n);
            dfs(grid, i, n - 1, m, n);
        }
        for(int j = 0; j < n; j++){
            dfs(grid, 0, j, m, n);
            dfs(grid, m - 1, j, m, n);            
        }
        for(int i = 1; i < m - 1; i++){
            for(int j = 1; j < n - 1; j++){
                if(grid[i][j] == 1){
                    ans++;
                }
            }
        }
        return ans;
    }

    public void dfs(int[][] grid, int i, int j, int m, int n){
        if(i < 0 || j < 0 || i >= m || j >= n || grid[i][j] == 0)
            return;
        grid[i][j] = 0;
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i, j - 1, m, n);
        dfs(grid, i, j + 1, m, n);
    }
}

1905. 统计子岛屿

image-20220312035609174

思路：可以参考下图，我的code没有他的beats多，但也浅显易懂吧。若1和2中的都是土地就把2此处值2，那么遍历对2中的每个2dfs,遇到1，表示此处1中为水，故不是子岛，flag置false，如果遇到2置0，继续dfs,

image-20220312040914977

class Solution {
boolean flag;//表示是否是子岛
    public int countSubIslands(int[][] grid1, int[][] grid2) {
        int m = grid1.length, n = grid1[0].length;
        int ans = 0;
        flag = true;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid1[i][j] == 1 && grid2[i][j] == 1)
                    grid2[i][j] = 2;//如果是2表示都是土地          
            }
        }
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid2[i][j] == 2){	//遇到2才dfs
                    dfs(grid2, i, j, m, n);
                    if(flag) ans++;
                    flag = true;
                }
            }
        }
        return ans;
    }

    public void dfs(int[][] grid2, int i, int j, int m, int n){
        if(i < 0 || j < 0 || i >= m || j >= n || grid2[i][j] == 0)
            return;
        //遇到1表示此处grid1中为水，直接false,return
        if(grid2[i][j] == 1){
            flag = false;	//注意这里如果return就不要将grid2[i][j]置0
            return;			//如果不return,继续dfs或者把grid2[i][j]置0再dfs都可
        }
        grid2[i][j] = 0;
        dfs(grid2, i - 1, j, m, n);
        dfs(grid2, i + 1, j, m, n);
        dfs(grid2, i, j - 1, m, n);
        dfs(grid2, i, j + 1, m, n);
    }
}

//他的code
class Solution {

    int rc;
    int cc;

    public int countSubIslands(int[][] grid1, int[][] grid2) {
        rc = grid1.length;
        cc = grid1[0].length;
        for (int i = 0; i < rc; i++) {
            for (int j = 0; j < cc; j++) {
                if (grid2[i][j] == 1) {
                    grid2[i][j] += grid1[i][j];
                }
            }
        }
        int res = 0;
        for (int i = 0; i < rc; i++) {
            for (int j = 0; j < cc; j++) {
                // DFS BFS任选一个
                if (grid2[i][j] == 2 && fill(grid2, i, j)) {
                    res++;
                }
            }
        }
        return res;
    }

    private boolean fill(int[][] grid, int i, int j) {
        if (i < 0 || i >= rc || j < 0 || j >= cc) {
            return true;
        }
        if (grid[i][j] != 2) {
            return grid[i][j] == 0;
        }
        grid[i][j] = 0;
        boolean down = fill(grid, i - 1, j);
        boolean up = fill(grid, i + 1, j);
        boolean right = fill(grid, i, j - 1);
        boolean left = fill(grid, i, j + 1);
        return down & up & right & left;
    }
}

后续待更新

忘眠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
leetcode(图论专题)
qq_46517733的博客
12-17 1693
图论1.导论2.编程题2.1 127. 单词接龙 1.导论 2.编程题 2.1 127. 单词接龙 字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列： 序列中第一个单词是 beginWord 。 序列中最后一个单词是 endWord 。 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典 wordList 中的单词。 给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到
Leetcode——图论
qq_43332536的博客
02-06 190
图论
LeetCode的基础入门（非常详细）零基础入门到精通，收藏这一篇就够了
最新发布
Libra1313的博客
04-25 1644
关于LeetCode都需要了解哪些？Python语法reduce(lambda x,y:x * y,ns) # 数组之乘积 (ns[0] * ns[1]) * ns[2]reduce(lambda x,y:x + y,ns) # 数组之和# 记忆化搜索# 大根堆# 过滤函数# 除数# 不可变str 常见函数strip([chars]) # 去除首末两端的字符, 默认是 \r,\n," "replace(old, new[, count]) # 字符串替换, old to new。
leetcode重点题目分类别记录（四）图论深入：并查集、二分图、DFS\BFS、拓扑排序、最小生成树、迪杰特拉斯
芸兮的博客
04-24 566
文章目录入度出度最大网络秩可以到达所有点的最少点数目并查集省份数量等式方程的可满足性按字典序排列最小的等效字符串以图判树二分图判断二分图深度优先搜索封闭岛屿数量太平洋大西洋水流问题广度优先搜索树上逃逸最短路径多源最短路径拓扑排序DFS解决拓扑排序BFS解决拓扑排序 入度出度 最大网络秩 直接相连的道路即为节点的度，如果两个节点是相连的，那么度将会重复计算，因此，统计每个节点的度，和节点相连的情况，每个每一对城市，计算最大网络秩。 int maximalNetworkRank(int n, vect
LeetCode：图论（BSF&DFS，最短路径，染色问题，拓扑结构，并查集）
燕双嘤
03-02 3291
13，24，79，85，127，130，200，210，256，269，329，417，444，542，547，684，695，733，752，785，797，815，841，947，953，994，997，1042，1091，1557，1901
LeetCode 题解随笔：图论（一）
weixin_44114160的博客
07-18 568
LeetCode 题解随笔：图论 刷题顺序参考：labuladong
LeetCode
02-13
在LeetCode上，你可以找到各种难度级别的问题，从入门到专家级别，帮助你准备面试或者自我提升。 在Java算法的实践中，LeetCode提供了丰富的题目，涵盖排序、搜索、图论、字符串处理、动态规划等多个领域。通过解决...
Leetcode:Leetcode问题的解决方案
04-14
1. **简单的** (Easy)：这类问题通常较为基础，适合初学者入门，或者作为热身练习。它们可能涉及到基本的数据类型操作、数组操作、字符串处理、基础逻辑判断等。例如，"两数之和"（Two Sum）问题，可以通过哈希表一...
LeetCode:LeetCode解题
07-23
首先，LeetCode平台涵盖了多种编程语言，如Java、Python、C++等，其题目难度从入门级到高级不等，涉及排序、搜索、图论、动态规划等多个主题。参与LeetCode的解题可以帮助你巩固基础，提高解决实际问题的能力，对于...
python基础学习资料
04-11
本资源"python基础学习资料"是针对零基础学习者的宝贵教程，涵盖了从入门到进阶的多个方面。 首先，这份资料包含"上机实验报告及源代码"，这是实践编程能力提升的关键部分。通过实际操作，你可以理解Python的基本...
ACM培训入门资料.7z
10-12
1. **基础算法**：ACM竞赛的基础在于扎实的算法知识，包括排序、搜索、图论、动态规划、回溯等。资料中可能会详细介绍这些基本算法的原理、应用场景以及如何在实际问题中运用。 2. **数据结构**：高效的数据结构...
[leetcode] 题型整理之图论
weixin_33830216的博客
12-29 552
图论的常见题目有两类，一类是求两点间最短距离，另一类是拓扑排序，两种写起来都很烦。 求最短路径： 127. Word Ladder Given two words (beginWordandendWord), and a dictionary's word list, find the length of shortest transformation sequence frombeg...
【LeetCode每日一题系列】图论：拓扑排序----异步操作
haojz
03-26 424
前言：这是一道笔试题目，虽然想到了拓扑排序，但是并没有对图论进行复习，因此对这道题目印象深刻，就该题讨论一下拓扑排序的实现 文章目录题目描述题目思路题目代码总结 题目描述 小美因为各种原因无法及时返校，为了完成学业，小美只能在家里上网课，网案由n个课程视频组成，编号为1到n。每个视频都需要从头看到比才算完成该部分的学习，且某个视频只能在看完指定的一些视频之后才能开始播故。因为小美的学习能力和她用来上网课的电脑性能都很好，所以小美可以同时观看任意多个课程视频，现在小美想知道，若她不眠不休地学习，每个课.
leetcode - 103道入门基础题
seaalan的博客
11-22 1678
一、leetcode - 字符串 二、leetcode - 二进制、数学类 三、leetcode - 数组 四、leetcode - 二分查找 五、leetcode - 快慢指针 六、leetcode - 滑动窗口 七、leetcode - 矩阵 八、leetcode - 栈和队列 九、leetcode - 链表 十、leetcode - 二叉树 十一、leetcode - 并查集 十二、leetcode - 回溯 十三、leetcode - 动态规划 十四、leetcode - 贪心 一、leetcode
LeetCode刷题顺序（新手入门）
falldeep的算法世界
11-06 4036
移动零给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。难点就是不复制原数组要原地修改，解法为设置一个res，记录前面的0的个数，每次插入时只要插入到nums[i - res]中即可移除元素给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
LeetCode刷题入门
murongjunxiaoxiao的博客
10-18 368
Letcode刷题入门篇 开始准备刷Letcode的题目，入门基础题
图论——leetcode
csdn_ggboy的博客
12-15 387
图论练习
Leetcode算法入门第十一天（递归 / 回溯）
君叶寒的博客
03-01 552
Leetcode算法入门第十一天（递归 / 回溯）：77. 组合，46. 全排列，784. 字母大小写全排列：回溯法经典题
【LeetCode】图论 graph（共20题）
weixin_30387423的博客
03-09 440
【133】Clone Graph（2019年3月9日，复习） 给定一个图，返回它的深拷贝。 题解：dfs 或者 bfs 都可以 1 /* 2 // Definition for a Node. 3 class Node { 4 public: 5 int val; 6 vector<Node*> neighbor...
[宫水三叶的刷题日记]：（图论）BFS1
08-03
宫水三叶的刷题日记专注于图论领域的学习和实战练习，特别是Breadth-First Search (BFS)算法的应用。该专题合集是针对LeetCode平台的题库，以帮助读者提升算法技能，特别是对于初学者和进阶者来说，提供了一个系统的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值