算法-图论

已于 2024-01-25 22:14:45 修改
阅读量906 收藏 22
点赞数 23
分类专栏： 算法 文章标签： 算法 java 图论
于 2024-01-22 21:51:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HBryce24/article/details/135717447
版权

一、理论基础

  1. 图
  2. DFS：一个方向一直搜，搜不下去了，再换方向 
    public void dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }
    for (选择：本节点所连接的其他节点){
        处理节点
        dfs(图，选择的节点); // 递归
        回溯，撤销处理结果
    }
}
  3. BFS：先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍。 
    public void bfs (){
    Deque<> deque = new LinkedList<>();
    deque初始化
    while (!deque.isEmpty()) {
        for (){
            处理本层数据        
        }
    }
}

二、所有可能的路径

  1. 题目
    1. 给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）
  2. 思路
    1. DFS+回溯
  3. 代码
    class Solution {
    List<List<Integer>> lists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();

    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        // dfs
        list.add(0);
        dfs(0, graph);
        return lists;
    }

    public void dfs(int start, int[][] graph) {
        if (start == graph.length - 1) {
            lists.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < graph[start].length; i++) {
            list.add(graph[start][i]);
            dfs(graph[start][i], graph);
            list.remove(list.size() - 1);
        }
    }
}

三、岛屿的数量

  1. 题目

    1. 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。

  2. 思路
    1. DFS/BFS
  3. 代码
    class Solution {
    public int numIslands(char[][] 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] == '0') {
                    continue;
                }
                res++;
                bfs(i, j, grid);
            }
        }
        return res;
    }

    // dfs
    public void dfs(int row, int col, char[][] grid) {
        if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length || grid[row][col] == '0') {
            return;
        }
        grid[row][col] = '0';
        dfs(row + 1, col, grid);
        dfs(row - 1, col, grid);
        dfs(row, col + 1, grid);
        dfs(row, col - 1, grid);
    }

    // BFS
    public void bfs(int row, int col, char[][] grid) {
        Deque<int[]> deque = new LinkedList<>();
        deque.offer(new int[] { row, col });
        while (!deque.isEmpty()) {
            for (int i = deque.size(); i > 0; i--) {
                int[] poll = deque.poll();
                int a = poll[0];
                int b = poll[1];
                if (a < 0 || b < 0 || a >= grid.length || b >= grid[0].length || grid[a][b] == '0') {
                    continue;
                }
                grid[a][b] = '0';
                deque.offer(new int[] { a + 1, b });
                deque.offer(new int[] { a - 1, b });
                deque.offer(new int[] { a, b + 1 });
                deque.offer(new int[] { a, b - 1 });
            }
        }
    }
}

四、岛屿的最大面积

  1. 题目

    1. 给你一个大小为 m x n 的二进制矩阵 grid 。岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。岛屿的面积是岛上值为 1 的单元格的数目。计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

  2. 思路
  3. 代码
    class Solution {

    public int maxAreaOfIsland(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] == 0) {
                    continue;
                }
                res = Math.max(res, bfs(i, j, grid));
            }
        }
        return res;
    }

    public int dfs(int row, int col, int[][] grid) {
        if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length || grid[row][col] == 0) {
            return 0;
        }
        grid[row][col] = 0;
        return 1 + dfs(row + 1, col, grid) + dfs(row - 1, col, grid) + dfs(row, col + 1, grid)
                + dfs(row, col - 1, grid);
    }

    public int bfs(int row, int col, int[][] grid) {
        int[][] dir = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
        Deque<int[]> deque = new LinkedList<>();
        deque.offer(new int[] { row, col });
        grid[row][col] = 0;
        int res = 1;
        while (!deque.isEmpty()) {
            int[] poll = deque.poll();
            for (int i = 0; i < 4; i++) {
                int a = poll[0] + dir[i][0];
                int b = poll[1] + dir[i][1];
                if (a < 0 || b < 0 || a >= grid.length || b >= grid[0].length || grid[a][b] == 0) {
                    continue;
                }
                grid[a][b] = 0;
                res++;
                deque.offer(new int[]{a, b});
            }
        }
        return res;
    }
}

五、飞地的数量

  1. 题目

    1. 给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。

  2. 思路
  3. 代码
    class Solution {
    boolean mark = false;
    int temp = 0;
    public int numEnclaves(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){
                    dfs(i, j, grid);
                    if (!mark){
                        res += temp;
                    }
                }
                mark = false;
                temp = 0;
            }
        }
        return res;
    }
    private void dfs(int x, int y, int[][] grid) {
        if (x < 0 || x > grid.length - 1 || y < 0 || y > grid[0].length - 1) {
            mark = true;
            return;
        }
        if (grid[x][y] == 0) {
            return;
        }
        grid[x][y] = 0;
        temp++;
        dfs(x + 1, y, grid);
        dfs(x - 1, y, grid);
        dfs(x, y + 1, grid);
        dfs(x, y - 1, grid);
    }
}

六、被围绕的区域

  1. 题目
    1. 给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。
  2. 思路
    1. 从地图周边出发，将周边空格相邻的'O'都做上标记
  3. 代码
    class Solution {
    char[][] res;
    public void solve(char[][] board) {
        res = new char[board.length][board[0].length];
        for (char[] r : res) {
            Arrays.fill(r, 'X');
        }
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (board[i][j] == 'O' && (i == 0 || j == 0 || i == board.length - 1 || j == board[0].length - 1)) {
                    dfs(i, j, board);
                }
            }
        }
        for (int i = 0; i < board.length; i++) {
            System.arraycopy(res[i], 0, board[i], 0, board[0].length);
        }
    }

    public void dfs(int row, int col, char[][] board) {
        if (row < 0 || col < 0 || row >= board.length || col >= board[0].length || board[row][col] == 'X') {
            return;
        }
        board[row][col] = 'X';
        res[row][col] = 'O';
        dfs(row + 1, col, board);
        dfs(row - 1, col, board);
        dfs(row, col + 1, board);
        dfs(row, col - 1, board);
    }
}

七、太平洋大西洋水流问题

  1. 题目
    1. 既可流向太平洋也可流向大西洋
  2. 思路
    1. 从太平洋边上的节点 逆流而上，将遍历过的节点都标记上。
    2. 从大西洋的边上节点 逆流而长，将遍历过的节点也标记上。
    3. 然后两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点。
  3. 代码
    class Solution {
    int[][] dir = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };

    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        List<List<Integer>> list = new ArrayList<>();
        boolean[][] usedA = new boolean[heights.length][heights[0].length];
        boolean[][] usedP = new boolean[heights.length][heights[0].length];
        for (int i = 0; i < heights.length; i++) {
            dfs(i, 0, heights, usedP);
            dfs(i, heights[0].length - 1, heights, usedA);
        }
        for (int j = 0; j < heights[0].length; j++) {
            dfs(0, j, heights, usedP);
            dfs(heights.length - 1, j, heights, usedA);
        }
        for (int i = 0; i < heights.length; i++) {
            for (int j = 0; j < heights[0].length; j++) {
                if (usedA[i][j] && usedP[i][j]) {
                    int a = i;
                    int b = j;
                    list.add(new ArrayList<>() {
                        {
                            add(a);
                            add(b);
                        }
                    });
                }
            }
        }
        return list;
    }

    public void dfs(int row, int col, int[][] heights, boolean[][] used) {
        if (used[row][col]) {
            return;
        }
        used[row][col] = true;
        for (int i = 0; i < 4; i++) {
            int a = row + dir[i][0];
            int b = col + dir[i][1];
            if (a < 0 || b < 0 || a > heights.length - 1 || b > heights[0].length - 1
                    || heights[row][col] > heights[a][b]) {
                continue;
            }
            dfs(a, b, heights, used);
        }
    }

}

八、最大人工岛

  1. 题目

    1. 给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。返回执行此操作后，grid 中最大的岛屿面积是多少？

  2. 思路
    1. 标记每个岛屿并记录面积
    2. 寻找为0的，搜索周围岛屿
  3. 代码
    class Solution {
    int temp = 2;
    int[][] dir = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };

    public int largestIsland(int[][] grid) {
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, 0);
        // 岛屿变成面积
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    map.put(temp, dfs(i, j, grid));
                    temp++;
                }
            }
        }
        int res = map.get(grid[0][0]);
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 0) {
                    int temp = 1;
                    Set<Integer> set = new HashSet<>();
                    for (int k = 0; k < 4; k++) {
                        int a = i + dir[k][0];
                        int b = j + dir[k][1];
                        if (a < 0 || b < 0 || a > grid.length - 1 || b > grid[0].length - 1) {
                            continue;
                        }
                        set.add(grid[a][b]);
                    }
                    for (int s : set) {
                        temp += map.get(s);
                    }
                    res = Math.max(res, temp);
                }
            }
        }
        return res;
    }

    public int dfs(int row, int col, int[][] grid) {
        if (row < 0 || col < 0 || row > grid.length - 1 || col > grid[0].length - 1 || grid[row][col] != 1) {
            return 0;
        }
        grid[row][col] = temp;
        return dfs(row + 1, col, grid) + dfs(row - 1, col, grid) + dfs(row, col + 1, grid) + dfs(row, col - 1, grid)
                + 1;
    }
}

九、单词接龙

  1. 题目
    1. 字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> ... -> sk
  2. 思路
    1. 点与点差一个字符便可建立连接关系
    2. 无向图求最短路，广搜最为合适，广搜只要搜到了终点，那么一定是最短的路径。因为广搜就是以起点中心向四周扩散的搜索。
  3. 代码
    1. class Solution {
    // 最短路径BFS
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) {
            return 0;
        }
        Set<String> set = new HashSet<>(wordList);
        Map<String, Integer> map = new HashMap<>();
        Deque<String> deque = new LinkedList<>();
        map.put(beginWord, 1);
        deque.offer(beginWord);
        while (!deque.isEmpty()) {
            String poll = deque.poll();
            int path = map.get(poll);
            for (int i = 0; i < poll.length(); i++) {
                char[] chs = poll.toCharArray();
                for (char j = 'a'; j <= 'z'; j++) {
                    chs[i] = j;
                    String newWord = String.valueOf(chs);
                    if (newWord.equals(endWord)) {
                        return path + 1;
                    }
                    if (set.contains(newWord) && !map.containsKey(newWord)) {
                        deque.offer(newWord);
                        map.put(newWord, path + 1);
                    }
                }
            }
        }
        return 0;
    }
}

十、钥匙和房间

  1. 题目
  2. 思路
    1. 有向图全路径
  3. 代码
    class Solution {
    boolean[] used;
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        used = new boolean[rooms.size()];
        used[0] = true;
        dfs(0, rooms);
        for (boolean use : used) {
            if (!use) {
                return false;
            }
        }
        return true;
    }

    public void dfs(int start, List<List<Integer>> rooms) {
        for (int index : rooms.get(start)) {
            if (used[index]) {
                continue;
            }
            used[index] = true;
            dfs(index, rooms);
        }
    }
}

十一、岛屿的周长

  1. 题目
  2. 思路
  3. 代码
    class Solution {
    int[][] dir = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };

    public int islandPerimeter(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] == 0) {
                    continue;
                }
                for (int k = 0; k < 4; k++) {
                    int a = i + dir[k][0];
                    int b = j + dir[k][1];
                    if (a < 0 || b < 0 || a > grid.length - 1 || b > grid[0].length - 1 || grid[a][b] == 0) {
                        res++;
                    }
                }
            }
        }
        return res;
    }
}

未完待续......

HBryce24
关注
专栏目录
算法－图论－Kruskal
Calm down & Carry on
04-22 2236
Kruskal
算法-图论模板（java实现）
05-29
经典图论算法题的模板实现，包括最短路，宽搜深搜，拓扑序列，二分图等问题。作者参加算法比赛的利器。现在免费送给你。适合参加蓝桥杯、PAT等算法比赛或者面试的图论基础知识。
java 图论算法包_玩转算法系列--图论精讲 面试升职必备（Java版）
weixin_33057949的博客
02-16 466
第1章 和bobo老师一起，玩转图论算法欢迎大家来到我的新课程：《玩转图论算法》。在这个课程中，我们将一起完整学习图论领域的经典算法，培养大家的图论建模能力。通过这个课程的学习，你将能够真正地，玩转图论算法：)第2章 图的基本表示千里之行，驶于足下。解决任何有一个图论算法问题，首先需要用基本的数据结构来表示图。在这一章，我们就将探索图的基本表示问题，学习邻接矩阵和邻接表，进而，也让同学们熟悉这个课...
【算法-图论基础】最短路径-弗洛伊德算法
Xmc_5201314的博客
02-20 1021
图论算法、最短路径、弗洛伊德算法
数模算法-图论算法
Dompink的博客
09-02 974
这类问题算法有很多， 包括： Dijkstra 、 Floyd 、 Prim 、 Bellman-Ford ，最大流，二分匹配等问题。   关于此类图论算法，可参考Introduction to Algorithms–算法导论，关于图算法的第22章-第26章。同时，本BLOG内经典算法研究系列，对Dijkstra算法有所简单描述，经典算法研究系列：二、Dijkstra 算法初探 http:/
数据结构与算法 - 图论
夕暮、迟的博客
02-06 1192
基本概念： 图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。 图论是一种表示 "多对多" 的关系 图是由顶点和边组成的：(可以无边，但至少包含一个顶点) 一组顶点：通常用 V(vertex) 表示顶点集合一
图论算法-图论的表示、分类及基本概念(系列1)
BUPT-WT的博客
04-01 346
什么是图论 图论的应用: 2. 图论的表示 3. 图论的分类
『ACM-算法-图论』算法竞赛进阶指南--hamilton路径（模板）
日拱一卒,功不唐捐
04-14 3150
> 哈密顿图（哈密尔顿图）（英语：Hamiltonian graph，或Traceable > graph）是一个无向图，由天文学家哈密顿提出，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。在图论中是指含有哈密顿回路的图，闭合的哈密顿路径称作哈密顿回路（Hamiltonian > cycle），含有图中所有顶点的路径称作哈密顿路径（Hamiltonian path）。 >天文学家哈密顿(William Rowan Hamilton) 提出，在一个有多个城市的地图网络中，寻找一条从给定的
java图论_玩转算法系列--图论精讲 面试升职必备（Java版）
weixin_29465407的博客
02-20 434
第1章 和bobo老师一起，玩转图论算法欢迎大家来到我的新课程：《玩转图论算法》。在这个课程中，我们将一起完整学习图论领域的经典算法，培养大家的图论建模能力。通过这个课程的学习，你将能够真正地，玩转图论算法：)第2章 图的基本表示千里之行，驶于足下。解决任何有一个图论算法问题，首先需要用基本的数据结构来表示图。在这一章，我们就将探索图的基本表示问题，学习邻接矩阵和邻接表，进而，也让同学们熟悉这个课...
floodfill算法 java_玩转算法系列--图论精讲 面试升职必备（Java版）
weixin_34874119的博客
02-23 301
玩转算法系列--图论精讲 面试升职必备(Java版)图论算法是所有计算机专业的同学必学的基础知识；也是在算法，数据结构，离散数学等领域的重要内容；是面试，升职，计算机专业考研，考博的必考内容；更是计算机网络，编译原理，社交网络算法等领域的基础。但是，由于图论算法本身的复杂性和抽象性，让大多数同学头疼不已。在这个课程中，bobo老师将用其独到的问题讲解方式，庖丁解牛，深入浅出，让大家在这个课程中，真...
大数据-算法-图论中的Randi指标与圈及其应用.pdf
04-17
大数据-算法-图论中的Randi指标与圈及其应用.pdf
大数据-算法-图论中的组合方法和概.pdf
04-17
大数据-算法-图论中的组合方法和概.pdf
图论算法- 图论概述.rar
09-16
图论算法- 图论概述.rar
扩展矩阵leetcode-imooc_algorithm_graph:慕课网《玩转算法系列--图论精讲》笔记及Golang代码实现
07-01
慕课网《玩转算法系列--图论精讲》笔记 明确变量的语义！！！ 忘记的概念 图的基本表示 联通分量（2-2 8:13） 树是一种无环图（2-2 10:26） 联通的无环图是树（2-2 11:27） 联通图的生成树包含所有顶点（2-2 12:38）...
Java 7大排序
m0_74270127的博客
05-10 801
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
[Easy] leetcode-35 搜索插入位置
Sofine
05-09 248
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
从零学算法6
m0_53256503的博客
05-11 988
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。输入：s = “PAYPALISHIRING”, numRows = 3。输入：s = “PAYPALISHIRING”, numRows = 4。输入：s = “A”, numRows = 1。输出：“PAHNAPLSIIGYIR”输出：“PINALSIGYAHRPI”
AtCoder Beginner Contest 353
最新发布
2301_78527293的博客
05-11 995
abc
基准算法求解图论-桥C++代码
05-21
下面是一个简单的基准算法求解图论中桥的 C++ 代码： ```cpp #include using namespace std; const int N=1e5+10; const int M=1e6+10; int n,m,dfn[N],low[N],tim,cnt,vis[N],head[N],ver[M],Next[M],tot; void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值