图论算法小结与题解

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量711 收藏 12
点赞数 28
文章标签： 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73171073/article/details/140913141
版权

图论

797. 所有可能的路径(DFS)

题目描述

给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）

graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。

示例 1：

输入：graph = [[1,2],[3],[3],[]]
输出：[[0,1,3],[0,2,3]]
解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3

示例 2：

输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

解析：

打印从起点到终点的所有路径，很显然需要从其一起点沿着路径一直遍历到最深处，因此采用dfs，采用dfs需要考虑好dfs的具体参数，以及参数有什么用，以及dfs结束条件和得到答案的条件

参数确定：

  • 对于本题，因为是从0走到n-1，那么需要一个u来表示当前走到了哪个节点
  • 因为要保存过程做所需要的路径，所以还需要一个路径集合，（一般dfs参数如果不想要放到参数中，还可以放在全局变量中来进行，这样dfs参数就少一点
  • 参数中需注意，我们在得到一组解之后需要对路径进行复制，不能直接将path放入ans中，因为是引用类型

结束条件：和一般dfs和树等操作一样，当出现越界等情况就直接返回

答案：当u(当前节点）为最后一个节点n-1

代码

class Solution {
    private LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        List<List<Integer>> ans = new ArrayList<>();
        int n=graph.length;
        path.add(0);
        dfs(0,ans,n,graph);
        return ans;

    }


    //u表示那个点
    private void dfs(int u, List<List<Integer>> ans,int n,int[][] graph) {
        if (u>=n)return;

        if (u==n-1){
            LinkedList<Integer> path1 = new LinkedList<>(path);
            ans.add(path1);

        }
        for (int next : graph[u]) {
            path.add(next);
            dfs(next,ans,n,graph);
            path.removeLast();
        }
     }
}

岛屿问题

200. 岛屿数量

题目描述

方法一：

DFS：本体使用dfs的话，作用就是将dfs的过程中将走过的路径进行标记，即当为陆地时继续dfs并且将该位置标记为已走过

所以格子有三种状态：

  • 0：水
  • 1：陆地
  • 2：已经走过的陆地

遍历当当前各自值为1的时候进行dfs，然后dfs完就代表以该格子的陆地块已经标记玩了，那么陆地板块就+1，最终返回答案

class Solution {
    //方法一：dfs
    //四个方向

    private int[] drict=new int[]{-1,0,1,0,-1};
    private int row,col;
    char[][] grid;
    public int numIslands(char[][] g) {
        grid=g;
        int ans=0;
        row=grid.length;
        col=grid[0].length;
        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);
                    ans++;

                }
            }
        }
        return ans;
    }

    private void dfs(int x, int y) {
        //越界
        if (x<0||x>=row||y<0||y>=col){
            return;
        }
        if (grid[x][y]!='1') return;
        //0:水
        //1：没遍历过的陆地
        //2：已经遍历过的陆地
        if (grid[x][y]=='1') grid[x][y]='2';

        for (int i = 0; i < 4; i++) {
            int newx=x+drict[i];
            int newy=y+drict[i+1];
            dfs(newx,newy);
        }


    }
}
方法二：并查集

首先我们常用的并查集的father数组都是一维的，所以这里需要将二维的坐标转化为一维坐标，本题只需要在并查集模板上稍微改造一下即可，即我们在初始化father数组时如果遇到1那么就set集合+1（即开始时默认每个陆地都是一个岛屿），然后每次可以合并时就将set--，最后返回set就是剩下的岛屿数

class Solution {
    //并查集所用
    public int MAXN=310;
    public int MAXM=310;
    public int[] father=new int[MAXM*MAXN];
    public int row,col;
    int set=0;
    char[][] grid;
    public void build(){

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                int index=transform(i,j);
                father[index]=index;
                if (grid[i][j]=='1'){
                    set++;
                }

            }
        }
    }
    public int find(int x){
        if (x!=father[x]){
            father[x]=find(father[x]);
        }
        return father[x];
    }
    public void union(int x,int y){
        int fx=find(x);
        int fy=find(y);
        if (fy!=fx){
            set--;
            father[fx]=fy;
        }

    }
    //二维坐标转一维
    public int transform(int x,int y){
        return x*col+y;

    }
    //方法二：并查集
    public int numIslands(char[][] g) {
        grid=g;
        row=g.length;
        col=g[0].length;
        build();
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {

                //往右
                if (j+1<col&&g[i][j]=='1'&&g[i][j+1]=='1'){
                    int index1=transform(i,j);
                    int index2=transform(i,j+1);
                    union(index1,index2);
                }
                //往下
                if (i+1<row&&g[i][j]=='1'&&g[i+1][j]=='1'){
                    int index1=transform(i,j);
                    int index2=transform(i+1,j);
                    union(index1,index2);
                }

            }

        }
        return set;


    }
}

695. 岛屿的最大面积

题目描述

class Solution {

    //方向
    int[] direct = new int[]{-1, 0, 1, 0, -1};
    int[][] grid;
    int n, m;

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

            }

        }
        return ans;


    }

    private int dfs(int x, int y) {
        if (x < 0 || x >= n || y < 0 || y >= m) return 0;
        if (grid[x][y] != 1) return 0;
        if (grid[x][y] == 1) grid[x][y] = 2;
        return 1 + dfs(x + 1, y)
                + dfs(x - 1, y)
                + dfs(x, y + 1)
                + dfs(x, y - 1);
    }
解析

这题和岛屿数量解法相同，唯一不同的时，岛屿数量求得是最终岛屿得总个数，而这个球的是最大大于面积

即岛屿数量得dfs主要作用是寻找同一块岛屿，然后给遍历过的岛屿标记

而求面积则需要在遍历过程中每经过一块地就+1，因此dfs需要返回对应的值

463. 岛屿的周长

解析

观察可知，周长就是岛屿的边界处，即越界或者下一步是水那么这一条边就是边界属于周长，因此我们在dfs时在越界处和下一步是水是返回1即可，同时核心走过的陆地同样标记为2

class Solution {

    int[][] grid;
    int n,m;
    int[] direct=new int[]{-1,0,1,0,-1};
    public int islandPerimeter(int[][] g) {
        grid=g;
        n=grid.length;
        m=grid[0].length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]==1) return dfs(i,j);

            }

        }
        return 0;


    }

    private int dfs(int x, int y) {
        if (x<0||x>=n||y<0||y>=m) return 1;
        if (grid[x][y]==0) return 1;
        if (grid[x][y]==2) return 0;

        //==1时候
        grid[x][y]=2;
        return dfs(x+1,y)
                +dfs(x-1,y)
                +dfs(x,y-1)
                +dfs(x,y+1);
    }


}

827. 最大人工岛

题目描述

解析

总结题目：有一个将水格子变成陆地的机会，然后需要找通过变化后的最大陆地面积

思路：

首相这里需要考虑到两个陆地可能通过这个变化各自连接成一个陆地，所以首先我们需要

  • 先进行一遍dfs这个dfs的作用就是
    • 1、给遍历过的同一陆地进行编号
    • 2、需要返回这个陆地的面颊
    • dfs完后将边号作为key，面积作为value存储来map中
  • 的到每个边号陆地的面积map后，我们需要再一次遍历图，找到图中值为0，即为水的地方将其来拼接面积，我们再进行另一个dfs
    • 这个dfs主要就是为了找到这个水格子相邻的陆地边号，注意，这个边号需要进行去重操作，防止陆地通过水格子自己连接自己的情况
    • 之后进行循环取最大值即可
class Solution {
    int[][] grid;
    int n,m;
    public int largestIsland(int[][] g) {
        grid=g;
        n=grid.length;
        m=grid[0].length;
        //第一个dfs为每个岛屿进行边号同时返回每个岛屿的面积，放在map中存储

        //岛屿边号从2开始，因为0，1已经有了自己的含义
        int index=2;
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]==1){
                    int erea=dfs(i,j,index);
                    map.put(index++,erea);
                }
            }
        }
        //看看有无特殊情况
        if (index==2){
            //说明全是水
            return 1;
        }
        int ans=0;

        //第二个dfs用来模拟将水换位陆地后找最大面积
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]==0){
                    //dfs得到相邻的去重后的集合
                    Set<Integer> set=dfs2(i,j);
                    int res=1;
                    for (Integer tag : set) {
                        res+=map.getOrDefault(tag,0);

                    }
                    ans=Math.max(ans,res);
                }

            }

        }
        //如果ans=0那么说明全是陆地没有水
        return ans==0?m*n:ans;

    }

    //定义四个方向
    int[] direct =new int[]{-1,0,1,0,-1};
    private Set<Integer> dfs2(int x, int y) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < 4; i++) {
            int newx=x+direct[i];
            int newy=y+direct[i+1];

            if (newx>=0&&newx<n&&newy>=0&&newy<m){
                set.add(grid[newx][newy]);
            }

        }
        return set;
    }

    private int dfs(int x, int y, int index) {
        if (x<0||x>=n||y<0||y>=m) return 0;
        if (grid[x][y]!=1) return 0;
        //到这就是陆地1了
        grid[x][y]=index;
        //计算面积
        return 1+dfs(x+1,y,index)
                +dfs(x-1,y,index)
                +dfs(x,y-1,index)
                +dfs(x,y+1,index);
    }


}

 

dijstra系列

模版

求单源最短路径

题目位置登录 - Luogu Spilopelia

import java.io.*;
import java.util.Arrays;
import java.util.PriorityQueue;

public class Main {
    public static int MAXN = 100010;
    public static int MAXM = 200010;
    //建图
    public static int[] head = new int[MAXN];
    public static int[] next = new int[MAXM];
    public static int[] to = new int[MAXM];
    public static int[] weigth = new int[MAXM];
    public static int cnt = 1;

    //dijstra用
    public static int[] distance = new int[MAXN];
    public static boolean[] visited = new boolean[MAXN];
    public static PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);

    //初始化
    public static void build(int n) {
        cnt = 1;
        Arrays.fill(head, 1, 1 + n, 0);
        Arrays.fill(distance, 1, 1 + n, Integer.MAX_VALUE);
        Arrays.fill(visited, 1, 1 + n, false);
    }

    //建图
    public static void buildEage(int u, int v, int w) {
        next[cnt] = head[u];
        to[cnt] = v;
        weigth[cnt] = w;
        head[u] = cnt++;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(System.out);

        in.nextToken();
        int n = (int) in.nval;
        in.nextToken();
        int m = (int) in.nval;
        in.nextToken();
        int s = (int) in.nval;

        //初始化
        build(n);
        //建图

        for (int j = 1; j <= m; j++) {
            in.nextToken();
            int u = (int) in.nval;
            in.nextToken();
            int v = (int) in.nval;
            in.nextToken();
            int w = (int) in.nval;
            buildEage(u, v, w);
        }


        //开始dj
        heap.offer(new int[]{s, 0});
        distance[s]=0;

        while (!heap.isEmpty()) {
            //弹出最小
            int[] poll = heap.poll();
            int cur = poll[0];
            int w = poll[1];
            if (visited[cur] == true) continue;
            //设为已访问
            visited[cur] = true;

            //消除影响
            for (int ei = head[cur]; ei != 0; ei = next[ei]) {
                int nex = to[ei];
                int nw = weigth[ei];
                //是否能更新
                if (!visited[nex] && w + nw < distance[nex]) {
                    heap.offer(new int[]{nex, w + nw});
                    distance[nex] = w + nw;
                }
            }

        }
        //打印
        for (int i = 1; i <= n; i++) {
            out.print(distance[i] + " ");
        }
        out.flush();
        out.close();
        br.close();


    }
}

1631. 最小体力消耗路径

题目描述

class Solution {
    //用dj变形
    //通常的DJ求的是单元最短路径
    //而这个题目相当于要求最大中的最小：即从所有导终点的路径的高度差最大值中找最小值
    //因此，我们distance数组中就保存最大的最小，即每次从堆中弹出来后，取弹出来权值和高度差取最大值然后和下一个点的distance作比较
    //按照dj思路进行操作
    public int minimumEffortPath(int[][] heights) {
        int n=heights.length;
        int m=heights[0].length;

        int[][] distacne=new int[n][m];
        boolean[][] visited=new boolean[n][m];
        //堆中含义：从远点（0，0）到（i,j)的最短路径为2
        //0:i
        //1:j
        //2:权值
        PriorityQueue<int[]> heap = new PriorityQueue<>((a,b)->a[2]-b[2]);
        for (int i = 0; i < n; i++) {
            Arrays.fill(distacne[i],Integer.MAX_VALUE);
            Arrays.fill(visited[i],false);
        }



        heap.offer(new int[]{0,0,0});
        //定义四个方向
        int[] direct=new int[]{-1,0,1,0,-1};
        distacne[0][0]=0;
        while (!heap.isEmpty()){
            //弹出
            int[] poll = heap.poll();
            int x=poll[0];
            int y=poll[1];
            int w=poll[2];
            if (visited[x][y]) continue;
            if (x==n-1&&y==m-1) return w;
            visited[x][y]=true;
            for (int i = 0; i < 4; i++) {
                int newx=x+direct[i];
                int newy=y+direct[i+1];
                if (newx<0||newx>=n||newy<0||newy>=m) continue;
                int mw=Math.max(w,Math.abs(heights[newx][newy]-heights[x][y]));
                if (!visited[newx][newy]&&mw<distacne[newx][newy]){
                    distacne[newx][newy]=mw;
                    heap.offer(new int[]{newx,newy,mw});
                }
            }
        }
        return -1;
    }
}

动态规划

阿东日志
关注
Python 练习题(1):n个结点的有向无环图个数
zoxiii的博客
03-04 1630
题目   用n表示结点的个数，$a_n$表示有$n$个结点的有向无环图个数。则有下面递推公式成立： $$a_n=\sum_{i=1}^n {(-1)}^{i+1}2^{(n-i)i}{n \choose i}a_{n-i}$$ - 编辑一个函数，计算$a_n$。 - 并且计算$a_{n},n=10,20,\cdots,100$。
数模常用算法——图论算法简介&代码实现
热门推荐
JiandaoStudio
06-19 1万+
图与网络优化概述 目录 1. 求 两个指定顶点之间的最短路径（Dijkstra算法） 2. 求每对顶点之间的最短距离（Floyd算法） 3.最小代价生成树 3.1 prim算法模板，当前测试点下标从0开始，输出从1开始： 3.2 kruskal算法模板： 4. 网络流 4.1最大流算法（最简单的EK算法） 4.2 二分最大权匹配 KM算法模板 4.3 最小...
图论算法 22.03.01
Mo_ney_z的博客
03-29 1273
图论 走迷宫 给定一个 n×mn×m 的二维整数数组，用来表示一个迷宫，数组中只包含 00 或 11，其中 00 表示可以走的路，11 表示不可通过的墙壁。 最初，有一个人位于左上角 (1,1)(1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。 请问，该人从左上角移动至右下角 (n,m)(n,m) 处，至少需要移动多少次。 数据保证 (1,1)(1,1) 处和 (n,m)(n,m) 处的数字为 00，且一定至少存在一条通路。 输入格式 第一行包含两个整数 nn 和 mm。 接下来 n
图论 理论以及相关题目题解的小结
菜鸡成长史
08-05 991
【图论】 吸吸吸国宝镇帖 目录 【图论】 理论 题解 【搜索】 【并查集】 【最小生成树】 【最短路】 【拓扑排序】 【二叉树】 【简单图】 【最小割】 理论 图论入门一 图论入门二 图论入门三 图论入门四 图论入门五 图论入门六 图论入门七-最小生成树 图论入门八-Kruskal算法 图论入门九-Prim算法 求最短路径的四种方法（...
[图论]Dijkstra 算法小结
一瓶93年的葡萄酒
01-09 729
Dijkstra 算法小结  By Wine93 2013.11 1 Dijkstra 算法相关介绍 算法阐述：Dijkstra是解决单源最短路径的算法,它可以在O(n^2)内计算出源点(s)到图中任何顶点的最短路,但是该算法不能处理存在负权边的图(证明中会给出)。 Dijkstra一般有2种实现，一种采用邻接矩阵，复杂度为O(n^2)，这种实现适用于稠密图 (边多点少
算法系列-----滑动窗口系列算法总结与题解一
m0_73171073的博客
08-19 1310
这个保证了左指针的值，不管当前扩展窗口位置在没在窗口中或者之前出现过没，如果没出现过那么值为-1，去max后还是左窗口值，如果出现过但是没在窗口中那么还是当前做窗口值，如果在窗口内，那么直接更新为窗口内该值的下一个坐标。这里使用滑动窗口比较巧妙，采用相减的差值来当滑动数组，具体看代码中的思路，需要注意的是，花这里需要保证窗口中维护的值一定要大于等于0，而我们采用的策略是可以先容忍窗口接收一个使得sum
【代码随想录训练营第42期 Day57打卡 - 图论Part7 - Prim算法与Kruskal算法
记得要努力变强
09-12 1452
Prim算法求解加权无向图的最小生成树
【题解】—— LeetCode一周小结12
ZShiJ的博客
03-25 1183
LeetCode每日一道一周小结12
洛谷题单——【图论2-3】最小生成树
qq_46126537的博客
01-01 389
P3366 【模板】最小生成树 一道模板题，prim算法就可以过，krustal算法也是可以的嗷 这里只给出prim的结法 #include <bits/stdc++.h> using namespace std; const int N = 5010; const int INF = 0x3f3f3f3f; int n, m; int g[N][N]; int dist[N]; bool st[N]; int prim() { memset(dist, 0x3f, sizeof(dis
C++基础动态规划与图论综合 挖地雷题解
C2020lax的博客
12-10 2328
题目描述： 在一个地图上有N个地窖，依次编号为1..N，每个地窖中埋有一定数量的地雷。同时，给出地窖之间的连接路径。 例如在下图中： 上图表示，地窖1可以挖到地窖2，地窖3；地窖2可以挖到地窖4；地窖3可以挖到地窖4，地窖5；地窖4可以挖到地窖5. 当地窖及其连接的数据给出之后，某人可以从任一处开始挖地雷，然后可以沿着某条路径接着往下挖（仅能选择一条路径），当某个地窖无连接时挖地雷工作结...
【AcWing算法基础】第三讲 搜索与图论
flowral的博客
11-06 258
一、DFS 1.1 排列数字 是全排列的问题，很经典的dfs题，没什么难度，硬敲就行 #include<iostream> using namespace std; const int N = 10; int n; int path[N]; bool st[N]; void dfs(int cnt){ if(cnt==n){ for(int i=0;i<n;i++){ cout<<path[i]<<" ";
图论（CSP-S难度）知识小结（完善中）
Park Corsa's CSDN Blog
10-20 2216
图论知识小结序言——先扯几句闲话--最短路--FLOYDSPFADijkstra次短路差分约束系统K短路分层图--生成树--PrimKruskal次小生成树最小树形图最小乘积生成树最优比率生成树--连通性--割点和桥SCCBCC--网络流--最大流费用流--匹配--2-SAT二分图--拓扑--拓扑排序树上背包--杂题--欧拉路LCA基环树线段树优化剩余系离散化 序言——先扯几句闲话 第一次写知识总...
ACM算法模板小汇总
羽歌Yo的博客
06-24 2599
一篇想到哪写到哪 · 不太全面的模板大集锦。
2015年湖南省第十一届大学生程序设计大赛 E题 “简单的图论问题?” CSG - 1116（最短路，dijkstra，图论）
saintjasper的博客
10-09 126
样例一：① 正常路线 10->3->6->14->8，值为41。② 转弯路线 10->3->6->2->6->14->8，值为49。② 若每一步不能与前一步的方向相同，也就是只能转弯或者后退，输出从这时从{r1,c1}到{r2,c2}最短路径。① 只能上下左右走，输出从{r1,c1}到{r2,c2}最短路径，路径长度就是所走格子的和。给一个n*m的矩阵，每一格要么是 * 代表障碍 ，要么是可走的1-100的整数。算是板子题，开始想的贪心，后来还是得弄四个方向的最短路才行。第一问直接dijkstra即可。
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5161
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
二叉树系列 10/11
2301_78191305的博客
10-11 420
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [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 236
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 189
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值