代码随想录-图论

已于 2024-04-13 20:13:02 修改
阅读量418 收藏 1
点赞数 1
文章标签： 图论 windows
于 2024-04-04 16:04:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71894372/article/details/137372114
版权
797.所有可能的路径：

. - 力扣（LeetCode）

class Solution {
    List<List<Integer>> ans=new LinkedList<>();
    List<Integer> list=new LinkedList<>();
    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        list.add(0);
        backTracking(graph,0);
        return ans;
    }
    private void backTracking(int[][] graph,int x){
        if (x==graph.length-1){
            ans.add(new LinkedList<>(list));
        }
        for (int i = 0; i < graph[x].length; i++) {
            list.add(graph[x][i]);
            backTracking(graph,graph[x][i]);
            list.remove(list.size()-1);
        }
    }
}
岛屿数量：

. - 力扣（LeetCode）

深搜：

class Solution {
    int ans=0;
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    public int numIslands(char[][] grid) {
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]=='1'){
                    ans++;
                    grid[i][j]='0';
                    backTracking(grid,i,j);
                }
            }
        }
        return ans;
    }
    private void backTracking(char[][] grid,int x,int y){
        for (int i = 0; i < 4; i++) {
            int newx=x+dx[i];
            int newy=y+dy[i];
            if (newx<0||newy<0||newx>=grid.length||newy>=grid[0].length||grid[newx][newy]=='0')continue;
            grid[newx][newy]='0';
            backTracking(grid,newx,newy);
        }
    }
}

广搜：

class Solution {
     int ans=0;
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    public int numIslands(char[][] grid) {
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]=='1'){
                    ans++;
                    bfs(grid,new boolean[grid.length][grid[0].length],i,j);
                }
            }
        }
        return ans;
    }

    private void bfs(char[][] grid,boolean[][] vis,int x,int y) {
        Deque<Pair> pairDeque=new LinkedList<>();
        pairDeque.push(new Pair(x,y));
        while (!pairDeque.isEmpty()){
            Pair pair = pairDeque.pop();
            int x1 = pair.x;
            int y1 = pair.y;
            for (int i = 0; i < 4; i++) {
                int newx=x1+dx[i];
                int newy=y1+dy[i];
                if (newx<0||newy<0||newx>=grid.length||newy>=grid[0].length||grid[newx][newy]=='0'){
                    continue;
                }
                grid[newx][newy]='0';
                pairDeque.push(new Pair(newx,newy));
            }
        }
    }
    class Pair{
        int x;
        int y;

        public Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}
岛屿的最大面积：
 

. - 力扣（LeetCode）

 int max=0;
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    int count=1;
    public int maxAreaOfIsland(int[][] grid) {
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]==1){
                    count=0;
                    dfs(grid,i,j);
                    max=Math.max(max,count);
                }
            }
        }
        return max;
    }
    private void dfs(int[][] grid,int x,int y){
        count++;
        grid[x][y]=0;
        for (int i = 0; i < 4; i++) {
            int newx=x+dx[i];
            int newy=y+dy[i];
            if (newx<0||newy<0||newx>=grid.length||newy>=grid[0].length||grid[newx][newy]==0){
                continue;
            }
            grid[newx][newy]=0;
            dfs(grid,newx,newy);
        }
    }

    public static void main(String[] args) {
        LeetCode695dfs leetCode695=new LeetCode695dfs();
        int max = leetCode695.maxAreaOfIsland(new int[][]{{1}});
        System.out.println(max);
    }
class Solution {
    int max=0;
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    int count=1;
    public int maxAreaOfIsland(int[][] grid) {
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]==1){
                    count=0;
                    bfs(grid,i,j);
                    max=Math.max(count,max);
                }
            }
        }
        return max;
    }
    private void bfs(int[][] grid,int x,int y){
        Deque<pair> pairDeque=new LinkedList<>();
        pairDeque.push(new pair(x,y));
        grid[x][y]=0;
        while (!pairDeque.isEmpty()){
            pair pop = pairDeque.pop();
            count++;
            int x1 = pop.x;
            int y1 = pop.y;
            for (int i = 0; i < 4; i++) {
                int newx=x1+dx[i];
                int newy=y1+dy[i];
                if (newx<0||newy<0||newx>=grid.length||newy>=grid[0].length||grid[newx][newy]==0){
                    continue;
                }
                grid[newx][newy]=0;
                pairDeque.push(new pair(newx,newy));
            }
        }
    }
    
    class pair{
        int x;
        int y;

        public pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}
1020：飞地的数量：

. - 力扣（LeetCode）

class Solution {
    int ans=0;
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    boolean flag=true;
    public int numEnclaves(int[][] grid) {
        for (int i = 0; i < grid[0].length; i++) {
            if (grid[0][i]==1){
                grid[0][i]=0;
                dfs(grid,0,i);
            }
            if (grid[grid.length-1][i]==1){
                grid[grid.length-1][i]=0;
                dfs(grid,grid.length-1,i);
            }
        }
        for (int i = 0; i < grid.length; i++) {
            if (grid[i][0]==1){
                grid[i][0]=0;
                dfs(grid,i,0);
            }
            if (grid[i][grid[0].length-1]==1){
                grid[i][grid[0].length-1]=0;
                dfs(grid,i,grid[0].length-1);
            }
        }
        for (int i = 1; i < grid.length-1; i++) {
            for (int j = 1; j < grid[0].length-1; j++) {
                if (grid[i][j]==1) ans++;
            }
        }
        return ans;
    }
    private void dfs(int[][] grid,int x,int y){
        for (int i = 0; i < 4; i++) {
            int newx=x+dx[i];
            int newy=y+dy[i];
            if (newx<0||newy<0||newx>=grid.length||newy>=grid[0].length||grid[newx][newy]==0){
                continue;
            }
            grid[newx][newy]=0;
            dfs(grid,newx,newy);
        }
    }
}

 这题广搜更胜一筹：


public class LeetCode1020bfs {
    int ans=0;
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    public int numEnclaves(int[][] grid) {
        for (int i = 0; i < grid[0].length; i++) {
            if (grid[0][i]==1){
                grid[0][i]=0;
                bfs(grid,0,i);
            }
            if (grid[grid.length-1][i]==1){
                grid[grid.length-1][i]=0;
                bfs(grid,grid.length-1,i);
            }
        }
        for (int i = 0; i < grid.length; i++) {
            if (grid[i][0]==1){
                grid[i][0]=0;
                bfs(grid,i,0);
            }
            if (grid[i][grid[0].length-1]==1){
                grid[i][grid[0].length-1]=0;
                bfs(grid,i,grid[0].length-1);
            }
        }
        for (int i = 1; i < grid.length-1; i++) {
            for (int j = 1; j < grid[0].length-1; j++) {
                if (grid[i][j]==1) ans++;
            }
        }
        return ans;
    }
    private void bfs(int[][] grid,int x,int y){
        Deque<pair> deque=new LinkedList<>();
        deque.push(new pair(x,y));
        grid[x][y]=0;
        while (!deque.isEmpty()){
            pair pop = deque.pop();
            int x1 = pop.x;
            int y1 = pop.y;
            for (int i = 0; i < 4; i++) {
                int newx=x1+dx[i];
                int newy=y1+dy[i];
                if (newx<0||newy<0||newx>=grid.length||newy>=grid[0].length||grid[newx][newy]==0){
                    continue;
                }
                grid[newx][newy]=0;
                deque.push(new pair(newx,newy));
            }
        }
    }
    class pair{
        int x;
        int y;

        public pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}
被围绕的区域：

 . - 力扣（LeetCode）

class Solution {
    int[] dx={0,1,-1,0};
    int[] dy={1,0,0,-1};
    public void solve(char[][] board) {
        int[][] flag=new int[board.length][board[0].length];
        for (int i = 0; i < board.length; i++) {
            if (board[i][0]=='O'){
                dfs(board,i,0,flag);
            }
            if (board[i][board[0].length-1]=='O'){
                dfs(board,i,board[0].length-1,flag);
            }
        }
        for (int i = 0; i < board[0].length; i++) {
            if (board[0][i]=='O'){
                dfs(board,0,i,flag);
            }
            if (board[board.length-1][i]=='O'){
                dfs(board,board.length-1,i,flag);
            }
        }
        for (int i = 1; i <board.length-1 ; i++) {
            for (int j = 1; j < board[0].length-1; j++) {
                if (flag[i][j]==0&&board[i][j]=='O'){
                    board[i][j]='X';
                }
            }
        }
    }

    private void dfs(char[][] board, int x, int y, int[][] flag) {
        flag[x][y]=1;
        for (int i = 0; i < 4; i++) {
            int newx=x+dx[i];
            int newy=y+dy[i];
            if (newx<0||newy<0||newx>=board.length||newy>=board[0].length||board[newx][newy]=='X'||flag[newx][newy]==1){
                continue;
            }
            dfs(board,newx,newy,flag);
        }
    }
}
****最大人工岛：

. - 力扣（LeetCode）

class Solution {
    int[] dx = {0, 1, -1, 0};
    int[] dy = {1, 0, 0, -1};
    int isLandNumber=2;
    int count=0;
    Map<Integer,Integer> map=new HashMap<>();
    public int largestIsland(int[][] grid) {
        int res=0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]==1){
                    count=0;
                    dfs(grid,i,j,isLandNumber);
                    map.put(isLandNumber,count);
                    res=Math.max(res,count);
                    isLandNumber++;
                }
            }
        }

        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                int area=0;
                Set<Integer> set=new HashSet<>();
                if (grid[i][j]==0){
                    for (int k = 0; k < 4; k++) {
                        int x=i+dx[k];
                        int y=j+dy[k];
                        if (x<0||y<0||x>=grid.length||y>=grid[0].length||grid[x][y]==0||set.contains(grid[x][y])){
                            continue;
                        }
                        area+=map.get(grid[x][y]);
                        set.add(grid[x][y]);
                    }
                }
                area++;
                res=Math.max(res,area);
            }
        }
        return res;
    }

    private void dfs(int[][] grid, int i, int j, int isLandNumber) {
        grid[i][j]=isLandNumber;
        count++;
        for (int k = 0; k < 4; k++) {
            int x=i+dx[k];
            int y=j+dy[k];
            if (x<0||y<0||x>=grid.length||y>=grid[0].length||grid[x][y]!=1){
                continue;
            }
            dfs(grid,x,y,isLandNumber);
        }
    }
}
****钥匙和房间：

. - 力扣（LeetCode）

 public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        boolean[] vis=new boolean[rooms.size()];
        dfs(rooms,vis,0);
        for (int i = 0; i < vis.length; i++) {
            if (vis[i]==false) return false;
        }
        return true;
    }

    private void dfs(List<List<Integer>> rooms, boolean[] vis, int i) {
        if (vis[i]==true){
            return;
        }
        List<Integer> list = rooms.get(i);
        vis[i]=true;
        for (Integer j : list) {
            dfs(rooms,vis,j);
        }
    }
***单词接龙：

. - 力扣（LeetCode）

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> set=new HashSet<>(wordList);
        if (!set.contains(endWord)){
            return 0;
        }
        LinkedList<String> queue=new LinkedList<>();
        Map<String,Integer> map=new HashMap<>();
        queue.offerLast(beginWord);
        map.put(beginWord,1);
        while (!queue.isEmpty()){
            String s = queue.removeFirst();
            Integer path = map.get(s);
            for (int i = 0; i < s.length(); i++) {
                char[] chars = s.toCharArray();
                for (char j = 'a'; j <='z'; j++) {
                    chars[i]=j;
                    String newword=new String(chars);
                    if (newword.equals(endWord)){
                        return path+1;
                    }
                    if (set.contains(newword)&&!map.containsKey(newword)){
                        map.put(newword,path+1);
                        queue.offerLast(newword);
                    }
                }
            }
        }
        return 0;
    }
}
***岛屿的周长：
class Solution {
    public int islandPerimeter(int[][] grid) {
        int sum=0;
        int cover=0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]==1){
                    sum++;
                    if (i-1>=0&&grid[i-1][j]==1) cover++;
                    if (j-1>=0&&grid[i][j-1]==1) cover++;
                }
                
            }
        }
        return sum*4-cover*2;
    }
}
class Solution {
    int[] dx={0,-1,1,0};
    int[] dy={1,0,0,-1};
    int C=0;
    public int islandPerimeter(int[][] grid) {
            for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j]==1){
                    for (int k = 0; k < 4; k++) {
                        int x=i+dx[k];
                        int y=j+dy[k];
                        if (x<0||y<0||x>=grid.length||y>=grid[0].length||grid[x][y]==0){
                            C++;
                        }
                    }
                }
            }
        }
        return C;
    }
}

鼠鼠想回浪浪山
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录-力扣刷题-总结笔记01
upward
02-27 942
代码随想录-力扣刷题-总结笔记01
代码随想录-力扣刷题-总结笔记02
upward
04-04 889
代码随想录-力扣刷题-总结笔记02
代码随想录——图论
weixin_44479862的博客
10-14 674
代码随想录——图论
代码随想录刷题攻略---图论1-深搜1
qq_54990658的博客
12-05 391
3.处理目前搜索节点出发的路径每一次搜索中，
代码随想录-算法训练营day61【代码随想录-算法训练营-总结】
upward
06-05 267
代码随想录-算法训练营day61【代码随想录-算法训练营-总结】
代码随想录刷题攻略---图论2-广搜1
qq_54990658的博客
12-05 364
1.dfs：搜索到终点之前，选定一条路走到黑，通过回溯改变路径，直到找到预期路径为止2.bfs：搜索到终点之前，从选定结点开始一圈一圈往外搜，一旦遇到终点，记录之前走过的节点就是一条最短路。当然，也有一些问题是 广搜 和 深搜 都可以解决的，例如岛屿问题，。
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 420
代码随想录-035期-算法训练营【博客笔记汇总表】
代码随想录——钥匙和房间（图论）
qq_39473176的博客
11-17 384
刷题总结
「代码随想录」图论之图的DFS遍历
weixin_44622140的博客
08-14 354
如果把二维矩阵中的每一个位置看做一个节点，这个节点的上下左右四个位置就是相邻节点，那么整个矩阵就可以抽象成一幅网状的「图」结构，使用visited数组来记录节点的访问情况。其实就是遍历二维数组（图）的每个值（节点），如果发现岛屿“1”，就使用DFS将连通的部分全部变为“0”（淹没岛屿），最后返回发现的岛屿数即可。graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。此处的graph为题目给出的图，root为当前搜索的根节点。
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录-大厂八股文-面试
04-25
"代码随想录-大厂八股文-面试" 从标题和描述中，我们可以看出这篇文章主要讲述的是代码随想录的大厂八股文面试相关知识点。下面将对这些知识点进行详细的解释和总结。 首先，代码随想录是一种常用的编程技巧，旨在...
代码随想录-大厂八股文稀有资源好几百页
04-19
付费渠道买的，请珍惜
00.代码随想录-最强八股文-第3版-无密版本.pdf
07-11
"代码随想录知识星球精华（最强八股文）第三版" 本资源摘要信息中，我们将根据给定的文件信息，生成相关知识点。 标题和描述中的知识点 * 代码随想录知识星球精华（最强八股文）第三版：这是一个关于编程的知识...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
【图论应用】使用多路图（multigraph）对上海地铁站点图建模，并解决最短路径问题
takedachia的博客
06-10 881
【图论应用】使用多路图（multigraph）对上海地铁站点图建模，并解决最短路径问题
算法笔记 图论和优先级队列的笔记
qq_46644680的博客
06-12 481
DFS stack O(h) 不具有最短性BFS queue O(2^h) 最短路迪杰斯特拉算法A0Auuvuvvvv。
图论第6天
weixin_41902984的博客
06-04 681
提高效率!!!两道题+看并查集。
图论（一）之概念介绍与图形#matlab
最新发布
m0_56619132的博客
06-15 880
图论——这一专注于点和线之间关系的学科，如同一条独特的脉络，将无数看似孤立的领域紧密地连接在一起。综上所述，图论是一门研究图及其相关性质的数学分支，具有广泛的应用背景和重要的理论价值。
代码随想录python
02-17
代码随想录是一个由CSDN开发的Python学习教程，它提供了丰富的Python编程知识和实例代码。以下是关于代码随想录Python的介绍： 1. 代码随想录Python是一个面向初学者的Python教程，它从基础知识开始，逐步介绍Python的各种概念和用法。 2. 代码随想录Python的内容包括但不限于：Python语法、数据类型、控制流、函数、模块、文件操作、异常处理、面向对象编程等。 3. 代码随想录Python以简洁明了的方式解释概念，并提供大量的实例代码帮助读者理解和掌握Python编程。 4. 代码随想录Python还提供了一些常见的Python编程题目和解答，帮助读者锻炼编程能力。 5. 代码随想录Python的教程内容经过精心编写和整理，适合初学者入门学习Python编程。 如果你对代码随想录Python感兴趣，可以通过CSDN网站或者其他渠道查找相关教程和资料。希望这个介绍对你有帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值