基础算法--搜索与图论（2）

最新推荐文章于 2024-11-05 21:58:11 发布
最新推荐文章于 2024-11-05 21:58:11 发布
阅读量2k 收藏 33
点赞数 28
分类专栏： 总结 文章标签： 算法 图论 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gj_863/article/details/135886406
版权

文章目录

最短路

n 表示点数量 m：边数量

稠密图：m和n^2是一个级别的

稀疏图：m和n一个级别

  • **单源最短路：**一个点到其他点的最短距离

    • 所有边权重都是正数：朴素Dijkstra算法 n^2，堆优化版Dijkstra算法 mlogn

      所以朴素的适合稠密图

    • 存在负权边：Bellman-Ford算法 nm ，SPFA 算法 一般是m，最坏nm

  • **多源汇最短路：**起点和终点都是不确定的

    • Foyld算法： n^3

单源最短路

dijkstra算法（朴素）

  1. 初始化距离：设一号点 dis[1] = 0 即到起点的距离为0，其他都为正无穷，dis[ i ] = +∞
  2. 循环n次，每次循环
    找到不在s（保存当前已经确定最短路径的点的集合）中的，距离最近的点t（这个t的现在的距离一定是最短路，具体可以证明），再将t加入集合s中，
    用t更新其他点的最短距离 查看dis[x] > dis[t] + t到x边的权重是否成立，是，就将x距离更新

每次循环就能确定一个点的最短路

模板：

public class Main{
    static final int N = 510;
    static int[]dist = new int[N];//每个点到起点的最短路
    static boolean[]st = new boolean[N];//这个点是否已经确定最短路
    static int[][]g = new int[N][N];//邻接矩阵存储稠密图
    static int MAX = 0x3f3f3f3f;
    static int n;//有几个点
    static int m;//有几个边

    static int dijkstra() {
        Arrays.fill(dist,MAX);
        dist[1] = 0;//初始化距离
        for(int i = 0;i < n;i++) {
            //找到一个距离起点最近且没确定最短路的点t
            int t = -1;
            for(int j = 1;j <= n;j++) {
                if(!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
            }
            //这个t此时与起点的距离就是该点的最短路
            st[t] = true;
            //用这个t更新其他点的距离
            for(int j = 1;j <= n;j++) {
                dist[j] = Math.min(dist[j],dist[t] + g[t][j]);//这里如果t和j无关联，那么g[t][j]就是MAX，dist[j]仍然是MAX
            }
        }
        //dist[n]是MAX说明n点与起点不存在路径
        if(dist[n] == MAX) return -1;
        return dist[n];
    }
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for(int i = 1;i <= n;i++) {
            for(int j = 1;j <= n;j++) {
                if(i == j) g[i][j] = 0;//自环边
                else g[i][j] = MAX;
            }
        }
        while(m --> 0 ) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            g[a][b] = Math.min(g[a][b],c);//a和b之间可能有多条路，取最短的一条
        }
        
        System.out.println(dijkstra());
    }
}

dijkstra算法（堆优化）

复杂度为mlogn

使用最小堆来优化找到一个距离起点最近且没确定最短路的点t过程

import java.util.*;

public class Main{
    static final int N = 150010;
    static int[]e = new int[N];
    static int[]h = new int[N];//使用邻接表来存稀疏图
    static int[]w = new int[N];
    static int[]ne = new int[N];
    static int[]dist = new int[N];
    static int M = 0x3f3f3f3f;
    static int idx;
    static int n;
    static int m;
    static PriorityQueue<int[]> heap = new PriorityQueue<>((a,b) -> a[1] - b[1]);
    static boolean[]st = new boolean[N];
    
    static int dijkstra() {
        Arrays.fill(dist,M);
        dist[1] = 0;
        heap.offer(new int[]{1,0});
        /*
         * 不优化的算法是采取暴力的方式，每次都把所有点遍历一遍，找st[j]=false且离起点最近的
         * 这里借助堆，每次将t更新完的其他点放入堆中，从堆中取出时，再用取出的点更新其他点，再次放入堆中
         */
        while(heap.size() != 0) {
            int[]a = heap.poll();
            int t = a[0];
            int distan = a[1];
            st[t] = true;
            for(int i = h[t];i != -1;i = ne[i]) {
                int j = e[i];
                if(dist[j] > distan + w[i]) {
                    dist[j] = distan + w[i];
                    heap.offer(new int[]{j,dist[j]});
                }
            }
        }
        
        if(dist[n] == M) return -1;
        return dist[n];
    }
    
    static void add(int a,int b,int c) {
        e[idx] = b;
        ne[idx] = h[a];
        w[idx] = c;
        h[a] = idx++;
    }
    public static void main(String[]args) {
        Arrays.fill(h,-1);
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        while(m --> 0) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            add(a,b,c);
        }
        
        System.out.println(dijkstra());
    }
}

存在负权边

Bellman-Ford算法

有边数限制的话，只能用它

图中不能存在负权回路，否则在回路中一直转圈，最短路就变成负无穷即不存在最短路

循环n次（表示最多不经过n条边）
    将dist复制给c，下边的循环用c中的数据更新dist（防止连路）
	循环所有边（a，b，w）
    	dis[b] = min(dist[b],copy[a] + w);//松弛操作

这样循环n次后，对于所有的点都满足三角不等式dist[b] <= dist[a] + w ，可以证明

直接用一个数组存放所有的边

public static int bellmanFord() {
    Arrays.fill(dist,M);
    dist[1] = 0;
    for(int i = 0;i < k;i++) {
        int[] c = Arrays.copyOf(dist, N);
        for(int j = 1;j <= m;j++) {
            int a = e[j].a;
            int b = e[j].b;
            int w = e[j].w;
            dist[b] = Math.min(dist[b],c[a] + w);
        }
    }
    if(dist[n] > M / 2) return M;
    return dist[n];
}
SPFA

实际上是对Bellman-ford算法的优化，主要思路是记录哪些点被更新了，再将和这些点有关系的点更新

迭代时用一个队列存放刚被更新的点（先将起点放入队列）

只要队列不空

​ 将对头t取出

​ 遍历更新一下t的所有出边b

​ 将b加入队列（b在队列中不存在的话）

public class Main{
    static final int N = 100010;
    static int n;
    static int m;
    static int[]h = new int[N];
    static int[]w = new int[N];
    static int[]ne = new int[N];
    static int[]e = new int[N];
    static boolean[]st = new boolean[N];
    static int idx;
    static int[]dist = new int[N];
    static int M = 0x3f3f3f3f;
    static void add(int x,int y,int z) {
        e[idx] = y;
        ne[idx] = h[x];
        w[idx] = z;
        h[x] = idx++;
    }
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        Arrays.fill(h,-1);
        while(m --> 0) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int z = sc.nextInt();
            add(x,y,z);
        }
        int t = spfa();
        if(t == M) System.out.println("impossible");
        else System.out.println(t);
    }
    
    public static int spfa() {
        Arrays.fill(dist,M);
        dist[1] = 0;
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        st[1] = true;
        
        while(!queue.isEmpty()) {
            int t = queue.poll();
            st[t] = false;
            for(int i = h[t];i != -1;i = ne[i]) {
                int j = e[i];
                if(dist[j] > dist[t] + w[i]) {
                    dist[j] = dist[t] + w[i];
                    if(!st[j]) {
                        queue.offer(j);
                        st[j] = true;
                    }
                }
            }
        }
        if(dist[n] == M) return M;
        return dist[n];
        
    }
    
}

多源汇求最短路

Flyod

初始时用邻接矩阵存储边d[i,j]

for(k = 1;k <= n;k++)
	for(i = 1;i <= n;i++)
		for(j = 1;j <= n;j++)
			d[i,j] = min(d[i,j],d[i,k]+d[k,j]);

模版：

import java.util.Scanner;

public class Main{
    static final int N = 210;
    static int[][]d = new int[N][N];
    static int M = 0x3f3f3f3f;
    static int n;
    static int m;
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        int k = sc.nextInt();
        for(int i = 1;i <= n;i++) {
            for(int j = 1;j <= n;j++) {
                if(i == j) d[i][j] = 0;
                else d[i][j] = M;
            }
        }
        while(m --> 0) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int z = sc.nextInt();
            d[x][y] = Math.min(d[x][y],z);
        }
        floyd();
        
        while(k --> 0) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            if(d[x][y] > M / 2) System.out.println("impossible");
            else System.out.println(d[x][y]);
        }
    }
    
    static void floyd() {
        for(int k = 1;k <= n;k++) {
            for(int i = 1;i <= n;i++) {
                for(int j = 1;j <= n;j++) {
                    d[i][j] = Math.min(d[i][j],d[i][k] + d[k][j]);
                }
            }
        }
    }
}

最小生成树

最小生成树问题一般对应无向图

一般稠密图用朴素版的Prim算法，稀疏图用Kruskal算法

  • Prim算法
    • 朴素版（稠密图）On^2
    • 堆优化版（稀疏图）Omlogn
  • Kruskal算法 Omlogm

Prim（朴素版）

集合：指当前已经在连通块中的点

到集合的距离：指到集合中的最近的点的距离

  1. 把所有距离初始化成正无穷
  2. n次迭代，每次迭代时，找到不在集合中的距离最近的点t，把t加到集合中（st[ t ] = true），用t来更新其他点到集合的距离
public class Main{
    static final int N = 510;
    static int[][]g = new int[N][N];
    static boolean[]st = new boolean[N];
    static int[]dist = new int[N];
    static int M = 0x3f3f3f3f;
    static int n;
    static int m;
    static int prim() {
        Arrays.fill(dist,M);
        int res = 0;//记录最小生成树的权重之和
        for(int i = 0;i < n;i++) {
            int t = -1;
            for(int j = 1;j <= n;j++) {
                if(!st[j] && (t == -1 || dist[j] < dist[t])) t = j;
            }
            st[t] = true;
            if(i != 0 && dist[t] == M) return M;//距离集合最近的点到集合的距离还是M，说明这个点和集合不连通，不存在最小生成树
            if(i != 0) res += dist[t];//这里将找到的一个结果加进结果集需要在根据t更新其他点到集合的距离之前，为了防止自环边的影响
            for(int j = 1;j <= n;j++) dist[j] = Math.min(dist[j],g[t][j]);
        }
        return res;
    }
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for(int i = 1;i <= n;i++) {
            for(int j = 1;j <= n;j++) {
                g[i][j] = M;
            }
        }
        while(m --> 0) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int z = sc.nextInt();
            g[x][y] = g[y][x] = Math.min(g[x][y],z);
        }
        
        int r = prim();
        if(r == M) System.out.println("impossible");
        else System.out.println(r);
    }
}

Krusal算法

  1. 将所有边按权重从小到大排序（该算法的一个瓶颈）
  2. 枚举每条边ab和权重c，如果a，b不连通（不在同一个集合中），将这条边加入集合 // 使用并查集
import java.util.*;
class Edge implements Comparable{
    int a;
    int b;
    int w;
    public Edge(int a,int b,int w) {
        this.a = a;
        this.b = b;
        this.w = w;
    }
    @Override
    public int compareTo(Object o) {
        Edge e = (Edge)o;
        return this.w - e.w;
    }
}

public class Main {
    static final int N = 100010;
    static int[]p = new int[N];
    static int find(int x) {
        if(x != p[x]) p[x] = find(p[x]);
        return p[x];
    }
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i = 1;i <= n;i++) p[i] = i;
        int m = sc.nextInt();
        Edge[]e = new Edge[m];
        for(int i = 0;i < m;i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            int w = sc.nextInt();
            e[i] = new Edge(u,v,w);
        }
        Arrays.sort(e);//将所有边按权重从小到大排序
        int res = 0;
        int cnt = 0;
        for(int i = 0;i < m;i++) {//如果两点之间根本不连通（没有边），那么根本不会枚举不存在的边
            int a = e[i].a;
            int b = e[i].b;
            int w = e[i].w;
            a = find(a);
            b = find(b);
            if(a != b) {//若两者根父节点不同，则两点不在同一个集合中
                p[a] = b;//并查集合并集合
                res += w;
                cnt++;
            }
        }
        if(cnt < n - 1) System.out.println("impossible");
        else System.out.println(res);
    }
}

二分图

一个图是二分图当且仅当图中不含奇数环。

二分图：图中所有点都可以分成两部分，每一部分之间没有边相连。

  • 如何判别一个图是不是二分图：染色法 On+m
  • 匈牙利算法 Onm，实际运行时间一般远小于nm

染色法

保证一条边的两个端点属于不同的集合，总共两个集合（即两种颜色）

for(int i = 1;i <= n;i++) {
	if (i 未染色) 
		dfs(i,k)  // 将i点颜色定为k，用深度优先遍历将i相连的点的颜色全部确定
}

import java.util.*;

public class Main{
    static int n;
    static int m;
    static final int N = 100010;
    static final int M = 200010;
    static int[]h = new int[N];
    static int[]e = new int[M];
    static int[]ne = new int[M];
    static int idx;
    static int[]col = new int[N];
    
    static void add(int a,int b) {
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }
    static boolean dfs(int k,int color) {
        col[k] = color;
        for(int i = h[k];i != -1;i = ne[i]) {
            int j = e[i];
            if(col[j] == 0) {
                if(!dfs(j,3 - color)) return false;
            }else if(col[j] == color) return false;
        }
        return true;
    }
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        Arrays.fill(h,-1);
        while(m --> 0) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            add(u,v);
            add(v,u);
        }
        
        for(int i = 1;i <= n;i++) {
            if(col[i] == 0) {
                if(!dfs(i,1)) {
                    System.out.println("No");
                    return;
                }
            }
        }
        System.out.println("Yes");
    }
}

练习：acwing 关押罪犯

匈牙利算法

没有两条边共用一个点称为成功匹配

匈牙利算法可以返回成功匹配最大的情况

public class Main{
    static final int N = 1010;
    static final int M = 100010;
    static int[]h = new int[N];
    static int[]e = new int[M];
    static int[]ne = new int[M];
    static int idx;
    static int n1;
    static int n2;
    static int m;
    static boolean[]st = new boolean[N];
    static int[]match = new int[N];//每个索引代表一个女嘉宾，索引下的值代表对应男嘉宾
    static void add(int a,int b) {
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }
    
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        n1 = sc.nextInt();
        n2 = sc.nextInt();
        m = sc.nextInt();
        Arrays.fill(h,-1);
        while(m --> 0) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            add(u,v);
        }
        int res = 0;
        for(int i = 1;i <= n1;i++) {
            Arrays.fill(st,false);
            if(find(i)) res++;
        }
        System.out.println(res);
    }
    static boolean find(int x) {
        for(int i = h[x];i != -1;i = ne[i]) {
            int j = e[i];
            if(!st[j]) {
                st[j] = true;//这里将他设置为true是为了在下面劝拥有这个妹子的男生找其他的妹子时不要重复找了这个妹子
                if(match[j] == 0 || find(match[j])) {//妹子待字闺中 或 成功分手
                    match[j] = x;//将这个妹子匹配给这个男生 牵手成功
                    return true; 
                }
            }
        }
        return false;
    }
}
算法基础--------【图论】
avalovef的博客
06-28 1258
图论（Graph Theory）是研究图及其相关问题的数学理论。图由节点（顶点）和连接这些节点的边组成。图论的研究范围广泛，涉及路径、流、匹配、着色等诸多问题。
Acwing-基础算法课笔记之搜索与图论
weixin_73381974的博客
01-15 1168
在上面的例子中，mySet.count(elementToFind) 返回元素 elementToFind 在 unordered_set 中出现的次数，因为在 unordered_set 中每个元素都是唯一的，所以该函数实际上只能返回 1 或 0。然后节点 1 接下来有两个路径分别是节点 2 和节点 3，填写距离两个节点的路径权值，并填写前面节点的记号，因为距离节点 2 最近，所以选择节点 2 的路径，并标记节点 2 已被经过。需要算出u的最大子树的节点数和u上面的部分的节点数，然后取二者的最大值即可。
搜索与图论 - spfa 算法
每天进步一点点！
12-17 3704
spfa 算法
算法-图论
jingyu_1的博客
07-15 1241
以下内容部分来自陈小玉老师的算法ppt，将图论中常见的算法进行汇总。包括图的存储以及图论的经典算法（最短路径、最小生成树）等。部分代码转自陈小玉老师的《算法训练营》。主要汇总了常用的图的存储和算法，建议初学者直接看B站的相关视频。...
[算法基础系列]图论基础算法详解
m0_64710378的博客
06-27 1129
需要熟悉的概念：（1）有向图和无向图（2）子图（3）连通，连通图和连通分量（4）生成树（5）顶点的度，入度和出度（6）边的权和网（7）稠密图和稀疏图yon（8）路径长度和回路。
数据结构与算法-图论-DFS/BFS
2303_76624483的博客
04-24 2667
我们首先定义一个图结构来表示城市中的路口（节点）和道路（边），然后实现 BFS 搜索找到最短路径。
Acwing-基础算法课笔记之搜索与图论（Floyd算法）
weixin_73381974的博客
01-25 604
Floyd算法就是利用中间节点来更新两节点间的距离，最后在求出最短路径。
Acwing算法基础课-搜索与图论-模板习题
qq_64403486的博客
04-17 1141
目录 一、DFS 1.排列数字 2.n-皇后问题 二、BFS 1.走迷宫 2.八数码 二、树与图的深度优先遍历DFS 树的重心 三、树与图的广度优先遍历BFS 图中点的层次 四、拓扑排序 有向图的拓扑序列 五、Dijkstra 1.Dijkstra求最短路I 2.Dijkstra求最短路II 六、bellman-ford 有边数限制的最短路 七、spfa 1.spfa求最短路 2.spfa判断负环 八、Floyd Floyd求最短路 九、Prim Prim
acwing算法基础之搜索与图论--kruskal算法
YMWM_的博客
11-11 1632
kruskal算法
Acwing-基础算法-第三章-搜素与图论
04-01
【Acwing-基础算法-第三章-搜索与图论】主要涵盖了两个核心概念：搜索算法和图论。在本章中，重点讲述了如何利用搜索算法解决图论问题。 1. **深度优先搜索（DFS, Depth-First Search）** - DFS是一种用于遍历或...
算法-基础算法- 模拟&思维（包含源程序）.rar
09-16
基础算法包括排序、搜索、图论、动态规划等。例如，排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等，它们各有优劣，在不同场景下有不同的效率表现。搜索算法则包括深度优先搜索（DFS）和广度优先...
算法-图论模板（java实现）
05-29
根据提供的文件内容，我们可生成...以上知识点的详细介绍，旨在帮助理解和掌握图论中的基础算法，以及在Java语言中的具体实现方式。通过这些知识点的学习，可以提高解决图论相关问题的能力，为算法比赛和面试做好准备。
图论算法- 图论概述.rar
09-16
这个名为"图论算法- 图论概述"的压缩包文件很可能是对图论基础知识的详细阐述，包括了图的基本概念、图的表示方法、图的遍历以及图的常用算法等内容。 首先，我们要理解什么是图。在数学和计算机科学中，图是由顶点...
算法刷题提高阶段-图论3
12-24
在这个“图论3”阶段，3.1.3 单源最短路的扩展应用.mp4这个视频很可能详细讲解了如何将这些基础算法应用于更复杂的问题中，例如多源最短路径、带有优先级的路径选择、流量最大化的网络设计等。可能还会讨论A*搜索...
算法基础-链表
August的专栏
11-05 222
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 330
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 308
Leetcode 160. 相交链表
二叉树(一)
m0_74340589的博客
11-05 433
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
JavaCV 图像边缘检测 之 Sobel算子 算法
欢迎拜读我的作品，喜欢的领域请给我留言
11-04 1518
JavaCV 是一个基于 OpenCV 和 FFmpeg 的 Java 计算机视觉库。它提供了对各种计算机视觉算法和图像处理功能的访问，包括图像读取、处理、显示，以及视频处理等。JavaCV 封装了底层的 C/C++ 库，使得在 Java 中进行计算机视觉开发更加方便快捷。本文详细介绍了JavaCV中的Sobel 算子在边缘检测中的应用。从Sobel 算子的原理出发，阐述了一阶导数与边缘检测的关系，以及Sobel 算子的卷积核和边缘检测过程。接着介绍了JavaCV的简介和Maven。
图论基础与算法实例讲解：构造与遍历
学习指南强调了图论在数据结构中的应用和在计算机科学中的实际操作，特别提到了需要掌握的算法设计题目，如图的定义与术语、存储表示、遍历算法、最小生成树算法、连通性和最短路径算法等。图的复杂性使得理解和实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值