算法基础学习笔记——⑪拓扑排序\最短路

博主:命运之光
✨专栏:算法基础学习

在这里插入图片描述

目录

✨拓扑排序

🍓朴素dijkstra算法:

🍓堆优化版dijkstra :

🍓Bellman-Ford算法

🍓spfa 算法(队列优化的Bellman-Ford算法)

🍓floyd算法:

✨图的存储


前言:算法学习笔记记录日常分享,需要的看哈O(∩_∩)O,感谢大家的支持!


拓扑排序

时间复杂度 O(n+m), n 表示点数,m 表示边数

bool topsort()
{
     int hh = 0, tt = -1;
     // d[i] 存储点i的入度
     for (int i = 1; i <= n; i ++ )
     	if (!d[i])
     		q[ ++ tt] = i;
     while (hh <= tt)
     {
         int t = q[hh ++ ];
         for (int i = h[t]; i != -1; i = ne[i])
         {
             int j = e[i];
             if (-- d[j] == 0)
             q[ ++ tt] = j;
         }
     }
     // 如果所有点都入队了,说明存在拓扑序列;否则不存在拓扑序列。
     return tt == n - 1;
}

拓扑排序

🍓朴素dijkstra算法:

时间复杂是 O(n2+m), n 表示点数,m 表示边数

int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 存储每个点的最短路是否已经确定
// 求1号点到n号点的最短路,如果不存在则返回-1
int dijkstra()
{
     memset(dist, 0x3f, sizeof dist);
     dist[1] = 0;
     for (int i = 0; i < n - 1; i ++ )
     {
         int t = -1; // 在还未确定最短路的点中,寻找距离最小的点
         for (int j = 1; j <= n; j ++ )
         	if (!st[j] && (t == -1 || dist[t] > dist[j]))
                 t = j;
         // 用t更新其他点的距离
         for (int j = 1; j <= n; j ++ )
         	dist[j] = min(dist[j], dist[t] + g[t][j]);
         st[t] = true;
     }
     if (dist[n] == 0x3f3f3f3f) return -1;
     return dist[n];
}

优化:

🍓堆优化版dijkstra :

时间复杂度 O(mlogn), n 表示点数,m 表示边数

typedef pair<int, int> PII;
int n; // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定
// 求1号点到n号点的最短距离,如果不存在,则返回-1
int dijkstra()
{
     memset(dist, 0x3f, sizeof dist);
     dist[1] = 0;
     priority_queue<PII, vector<PII>, greater<PII>> heap;
     heap.push({0, 1}); // first存储距离,second存储节点编号
     while (heap.size())
     {
         auto t = heap.top();
         heap.pop();
         int ver = t.second, distance = t.first;
         if (st[ver]) continue;
         st[ver] = true;
         for (int i = h[ver]; i != -1; i = ne[i])
         {
             int j = e[i];
             if (dist[j] > distance + w[i])
             {
                 dist[j] = distance + w[i];
                 heap.push({dist[j], j});
             }
         }
     }
     if (dist[n] == 0x3f3f3f3f) return -1;
     return dist[n];
}

🍓Bellman-Ford算法

处理有负权边的

优化:spfa

🍓spfa 算法(队列优化的Bellman-Ford算法)

时间复杂度 平均情况下 O(m),最坏情况下 O(nm), n 表示点数,m 表示边数

int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储每个点到1号点的最短距离
bool st[N]; // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离,如果从1号点无法走到n号点则返回-1
int spfa()
{
     memset(dist, 0x3f, sizeof dist);
     dist[1] = 0;
     queue<int> q;
     q.push(1);
        st[1] = true;
     while (q.size())
     {
         auto t = q.front();
         q.pop();
         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]) // 如果队列中已存在j,则不需要将j重复插入
                 {
                     q.push(j);
                     st[j] = true;
                 }
             }
         }
     }
     if (dist[n] == 0x3f3f3f3f) return -1;
     return dist[n];
}

spfa求负环:

spfa判断图中是否存在负环:

时间复杂度是 O(nm), n 表示点数,m 表示边数

int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离,cnt[x]存储1到x的最短路中经过的点数
bool st[N]; // 存储每个点是否在队列中
// 如果存在负环,则返回true,否则返回false。
bool spfa()
{
     // 不需要初始化dist数组
     // 原理:如果某条最短路径上有n个点(除了自己),那么加上自己之后一共有n+1个点,由抽屉原理一定有两个点相同,所以存在环。
     queue<int> q;
     for (int i = 1; i <= n; i ++ )
     {
    	 q.push(i);
         st[i] = true;
     }
     while (q.size())
     {
         auto t = q.front();
         q.pop();
         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];
                 cnt[j] = cnt[t] + 1;
                 if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点(不包括自己),则说明存在环
                 if (!st[j])
                 {
                     q.push(j);
                     st[j] = true;
                 }
             }
         }
     }
     return false;
}

Floyd //可以处理带有负权边的图,但不能处理带有负环的图

🍓floyd算法:

时间复杂度是 O(n3), n 表示点数

初始化:

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] = INF;
// 算法结束后,d[a][b]表示a到b的最短距离
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] = min(d[i][j], d[i][k] + d[k][j]);
}

最短路算法模板大总结:

我们只需考虑有向图上的算法,因为无向图是特殊的有向图。我们可以将所有无向边 u↔vu↔v,都拆分成两 条有向边:u←vu←v 和 u→vu→v。 为了方便叙述,我们做如下约定:n 表示图中点数,m 表示图中边数。

✨图的存储

图一般有两种存储方式:

邻接矩阵。开个二维数组,g[i][j] 表示点 i 和点 j 之间的边权。

邻接表。邻接表有两种常用写法,我推荐第二种,代码更简洁,效率也更高,后面有代码模板:

(1) 二维vector:vector<vector<int>> edge,edge[i][j] 表示第 i 个点的第 j 条邻边。

(2) 数组模拟邻接表:为每个点开个单链表,分别存储该点的所有邻边。

最短路算法

最短路算法分为两大类:

单源最短路,常用算法有:

(1) dijkstra,只有所有边的权值为正时才可以使用。在稠密图上的时间复杂度是 O(n2),稀疏图上的时间复杂度是 O(mlogn)。

(2) spfa,不论边权是正的还是负的,都可以做。算法平均时间复杂度是 O(km),k 是常数。 强烈推荐该算法。

多源最短路,一般用floyd算法。代码很短,三重循环,时间复杂度是 O(n3)。

算法模板

我们以 poj2387 Til the Cows Come Home 题目为例,给出上述所有算法的模板。

题目大意 给一张无向图,n 个点 m 条边,求从1号点到 n 号点的最短路径。

输入中可能包含重边。 dijkstra算法 O(n2)最裸的dijkstra算法,不用堆优化。每次暴力循环找距离最近的点。

只能处理边权为正数的问题。

图用邻接矩阵存储。

🍓C++ 代码

#include <cstdio> 
#include <cstring> 
#include <iostream> 
#include <algorithm> 
using namespace std; 
const int N = 1010, M = 2000010, INF = 1000000000; 
int n, m;
int g[N][N], dist[N]; // g[][]存储图的邻接矩阵, dist[]表示每个点到起点的距离 
bool st[N]; // 存储每个点的最短距离是否已确定 
void dijkstra() 
{ 
     for (int i = 1; i <= n; i++) dist[i] = INF; 
     dist[1] = 0; 
     for (int i = 0; i < n; i++) 
     { 
         int id, mind = INF; 
         for (int j = 1; j <= n; j++) 
             if (!st[j] && dist[j] < mind) 
             { 
                 mind = dist[j]; 
                 id = j; 
             } 
         st[id] = 1; 
         for (int j = 1; j <= n; j++) dist[j] = min(dist[j], dist[id] + g[id][j]); 
     } 
} 
int main() 
{ 
     cin >> m >> n; 
     for (int i = 1; i <= n; i++) 
         for (int j = 1; j <= n; j++) 
    		 g[i][j] = INF; 
     for (int i = 0; i < m; i++) 
     { 
         int a, b, c; 
         cin >> a >> b >> c; 
         g[a][b] = g[b][a] = min(g[a][b], c); 
     } 
     dijkstra(); 
     cout << dist[n] << endl; 
     return 0; 
}

dijkstra+heap优化 O(mlogn)

用堆维护所有点到起点的距离。时间复杂度是 O(mlogn)。

这里我们可以手写堆,可以支持对堆中元素的修改操作,堆中元素个数不会超过 n。也可以直接使用STL中的 priority_queue,但不能支持对堆中元素的修改,不过我们可以将所有修改过的点直接插入堆中,堆中会有重复 元素,但堆中元素总数不会大于 m。

只能处理边权为正数的问题。

图用邻接表存储。

🍓C++ 代码

typedef pair<int, int> PII;
int n; // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定
// 求1号点到n号点的最短距离,如果不存在,则返回-1
int dijkstra()
{
     memset(dist, 0x3f, sizeof dist);
     dist[1] = 0;
     priority_queue<PII, vector<PII>, greater<PII>> heap;
     heap.push({0, 1}); // first存储距离,second存储节点编号
     while (heap.size())
     {
         auto t = heap.top();
         heap.pop();
         int ver = t.second, distance = t.first;
         if (st[ver]) continue;
         st[ver] = true;
         for (int i = h[ver]; i != -1; i = ne[i])
         {
             int j = e[i];
             if (dist[j] > distance + w[i])
             {
                 dist[j] = distance + w[i];
                 heap.push({dist[j], j});
             }
         }
     }
     if (dist[n] == 0x3f3f3f3f) return -1;
     return dist[n];
}

spfa算法 O(km)

bellman-ford算法的优化版本,可以处理存在负边权的最短路问题。

最坏情况下的时间复杂度是 O(nm),但实践证明spfa算法的运行效率非常高,期望运行时间是 O(km) ,其中 k 是常数。 但需要注意的是,在网格图中,spfa算法的效率比较低,如果边权为正,则尽量使用 dijkstra 算法。

图采用邻接表存储。

队列为手写的循环队列。

🍓C++ 代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1010, M = 2000010, INF = 1000000000;
int n, m;
int dist[N], q[N]; // dist表示每个点到起点的距离, q 是队列
int h[N], e[M], v[M], ne[M], idx; // 邻接表
bool st[N]; // 存储每个点是否在队列中
void add(int a, int b, int c)
{
	e[idx] = b, v[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void spfa()
{
     int hh = 0, tt = 0;
     for (int i = 1; i <= n; i++) dist[i] = INF;
     dist[1] = 0;
     q[tt++] = 1, st[1] = 1;
     while (hh != tt)
     {
         int t = q[hh++];
         st[t] = 0;
         if (hh == n) hh = 0;
         for (int i = h[t]; i != -1; i = ne[i])
             if (dist[e[i]] > dist[t] + v[i])
             {
                 dist[e[i]] = dist[t] + v[i];
                 if (!st[e[i]])
                 {
                     st[e[i]] = 1;
                     q[tt++] = e[i];
                     if (tt == n) tt = 0;
                 }
             }
     }
}
int main()
{
     memset(h, -1, sizeof h);
     cin >> m >> n;
     for (int i = 0; i < m; i++)
     {
         int a, b, c;
         cin >> a >> b >> c;
         add(a, b, c);
         add(b, a, c);
     }
     spfa();
     cout << dist[n] << endl;
     return 0;
}

floyd算法 O(n3)

标准弗洛伊德算法,三重循环。循环结束之后 d[i][j] 存储的就是点 i 到点 j 的最短距离。

需要注意循环顺序不能变:第一层枚举中间点,第二层和第三层枚举起点和终点。

由于这道题目的数据范围较大,点数最多有1000个,因此floyd算法会超时。

但我们的目的是给出算法模板哦~

🍓C++ 代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1010, M = 2000010, INF = 1000000000;
int n, m;
int d[N][N]; // 存储两点之间的最短距离
int main()
{
     cin >> m >> n;
     for (int i = 1; i <= n; i++)
     	for (int j = 1; j <= n; j++)
     		d[i][j] = i == j ? 0 : INF;
     for (int i = 0; i < m; i++)
     {
         int a, b, c;
         cin >> a >> b >> c;
         d[a][b] = d[b][a] = min(c, d[a][b]);
     }
     // 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] = min(d[i][j], d[i][k] + d[k][j]);
     cout << d[1][n] << endl;
     return 0;
}

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
cda备考学习学习笔记——基础知识篇(二)主要涉及了计算机科学与技术领域的基本概念和知识。 首先,它介绍了计算机网络的基础知识。网络是将多台计算机通过通信链路连接起来,使它们能够相互通信和共享资源的系统。笔记中详细介绍了网络的组成、拓扑结构和通信协议等重要内容。 其次,笔记还解释了计算机系统的基本组成。计算机系统由硬件和软件两部分组成,其中硬件包括中央处理器、存储器、输入输出设备等,而软件则分为系统软件和应用软件。笔记详细介绍了各种硬件和软件的功能和作用。 此外,笔记还对数据库管理系统进行了介绍。数据库管理系统是一种用于管理和组织数据的软件系统,它能够实现数据的存储、检索和更新等操作。笔记中详细介绍了数据库的概念、结构和操作等内容。 最后,笔记还包括了算法和数据结构的基础知识。算法是解决问题的一系列步骤和规则,而数据结构则是组织和存储数据的方式。笔记中介绍了常用的算法和数据结构,如排序算法、树和图等。 总之,通过学习CDA备考学习笔记中的基础知识篇(二),我们能够更好地理解计算机网络、计算机系统、数据库管理系统以及算法和数据结构等相关概念和知识。这些基础知识对于我们深入研究计算机科学与技术领域是非常重要的,也为我们日后的学习和工作奠定了坚实的基础

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

命运之光

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值