最短路算法

最新推荐文章于 2024-10-20 23:59:56 发布

Lannnnh.

最新推荐文章于 2024-10-20 23:59:56 发布

阅读量115

点赞数

分类专栏：数据结构文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_39567491/article/details/104027985

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

最短路算法笔记

Dijkstra算法

Dijkstra算法基于贪心思想，它适用于所有边长的长度都是非负数的图。当边长 $z$ 都是非负数时，全局最小值不再可能被其他节点更新，故在第 $i$ 步中选出的节点x必然满足： $d i s t [x]$ 已经是起点到 $x$ 的最短路径。我们不断的选择全局最小值进行标记和扩展，最终可以得到起点1到每个节点的最短路径的长度。

#include <bits/stdc++.h>
using namespace std;

const int N = 505;

int n, m;
int a[N][N], d[N];
bool vis[N];

void dij()
{
    memset(vis, 0, sizeof(vis));
    memset(d, 0x3f, sizeof(d));
    d[1] = 0;
    
    // 更新n-1次
    for (int i = 1; i < n; ++ i )
    {
        int x = 0;
        // x == 0第一次进来只要没有访问过的点就赋值给x
        // 然后从中找到没有访问过的最短路径点,全局最小值
        for (int j = 1; j <= n; ++ j )
        {
            if (!vis[j] && (x == 0 || d[j] < d[x])) x = j;
        }
        
        vis[x] = 1;
        
        for (int y = 1; y <= n; ++ y )
            d[y] = min(d[y], d[x]+a[x][y]);
    }
}

int main()
{
    cin >> n >> m;
    memset(a, 0x3f, sizeof(a));
    for (int i = 1; i <= n; ++ i ) a[i][i] = 0;
    for (int i = 1; i <= m; ++ i ) 
    {
        int x, y, z;
        cin >> x >> y >> z;
        a[x][y] = min(z, a[x][y]);
    }
    
    dij();
    
    if (d[n] == 0x3f3f3f3f) cout << -1 << endl;
    else cout << d[n] << endl;
    
    return 0;
}

这个算法的时间复杂度为 $O(n^2)$ ，主要瓶颈在于第一步的寻找全局最小值的过程。可以使用二叉堆对dist数据进行维护，用 $O (l o g n)$ 的时间获取最小值并从堆中删除，用 $O (l o g n)$ 的时间执行一条边的扩展和更新，最终可在 $O (m l o g n)$ 的时间内实现Dijkstra算法。

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;

int n, m;
int ver[N<<1], edge[N<<1], nexts[N<<1], head[N<<1], d[N], tot = 0;
bool vis[N];
// 小根堆
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q; 

void add(int x, int y, int z)
{
    ver[++tot] = y, edge[tot] = z, nexts[tot] = head[x], head[x] = tot; 
}

void dij()
{
    memset(vis, 0, sizeof(vis));
    memset(d, 0x3f, sizeof(d));
    d[1] = 0;
    q.push({0, 1});
    
    while (!q.empty())
    {
        int x = q.top().second; q.pop();
        if (vis[x]) continue;
        for (int i = head[x]; i; i = nexts[i])
        {
            int y = ver[i], z = edge[i];
            if (d[y] > d[x]+z)
            {
                d[y] = d[x]+z;
                q.push({d[y], y});
            }
        }
    }
}

int main()
{
    cin >> n >> m;
    
    for (int i = 1; i <= m; ++ i ) 
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
    
    dij();
    
    if (d[n] == 0x3f3f3f3f) cout << -1 << endl;
    else cout << d[n] << endl;
    
    return 0;
}

Bellman-Ford算法

在有向图里面，如果所有边都满足 $\leq dis[x]+z$ ，那么这个 $d i s$ 数组就是我们需要的最短路径。

基于迭代思想的Bellman-Ford算法流程：

扫描所有边 $(x, y, z)$ ,若 $d i s [y] > d i s [x] + z$ ，则用 $d i s [x] + z$ 更新 $d i s [y]$ 。
重述上述步骤，直到没有更新操作发生。

Bellman-Ford算法的时间复杂度为 $O (n m)$ 。

int n, m;       // n表示点数，m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离

struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
{
    int a, b, w;
} edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i ++ )
    {
        for (int j = 0; j < m; j ++ )
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)
                dist[b] = dist[a] + w;
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

SPFA算法

SPFA算法流程：

建立一个队列，最初队列里只含有起点1。
取出队头节点 $x$ ，扫描它的所有出边 $(x, y, z)$ ，若 $d i s [y] > d i s [x] + z$ ，则使用 $d i s [x] + z$ 更新 $d i s [y]$ 。同时，若 $y$ 不在队列中，则把 $y$ 入队。
重述上述步骤，直到队列为空。

在随机图上，SPFA算法的时间复杂度为 $O (k m)$ ，k是一个较小的常数。但是在特殊构造的图上会退化为 $O (n m)$ 。

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5+5;
int n, m;
int ver[N], edge[N], head[N], nexts[N], tot = 0, dis[N];
bool vis[N];

void add(int x, int y, int z)
{
    ver[++tot] = y, edge[tot] = z, nexts[tot] = head[x], head[x] = tot;
}

void spfa()
{
	memset(dis, 0x3f, sizeof(dis));
    
    dis[1] = 0;
    vis[1] = true;
    queue<int> q;
    q.push(1);
    
    while (!q.empty())
    {
        int x = q.front(); q.pop();
        vis[x] = false;
        
        for (int i = head[x]; i; i = nexts[i])
        {
            int y = ver[i], z = edge[i];
            if (dis[y] > dis[x]+z) 
            {
                dis[y] = dis[x]+z;
                if (!vis[y]) { q.push(y); vis[y] = true; }
            }
        }
    }
}

int main()
{
    cin >> n >> m;
    
    for (int i = 1; i <= m; ++ i ) 
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
    
    spfa();
    
    if (dis[n] == 0x3f3f3f3f) cout << "impossible" << endl;
    else cout << dis[n] << endl;
    
    return 0;
}

还可以利用SPFA来判断图中是否有负环！

bool spfa()
{
    queue<int> q;
    for (int i = 1; i <= n; ++ i )
    {
        q.push(i);
        vis[i] = true;
    }
    
    while (!q.empty())
    {
        int x = q.front(); q.pop();
        vis[x] = false;
        
        for (int i = head[x]; i; i = nexts[i])
        {
            int y = ver[i], z = edge[i];
            // 存在负边权时才成立
            if (dis[y] > dis[x]+z) 
            {
                dis[y] = dis[x]+z;
                cnt[y] = cnt[x]+1;
                // 存在负环
                if (cnt[y] >= n) return true;
                if (!vis[y]) { q.push(y); vis[y] = true; }
            }
        }
    }
    return false;
}

任意两点间最短路径—Floyd算法

求出图中任意两点间的最短路径，也可以把每个点作为起点，求解N次单源最短路径问题。不过，在任意两点间最短路问题中，图一般比较稠密。使用Floyd算法可以在 $O(n^3)$ 的时间内完成求解。

#include <bits/stdc++.h>
using namespace std;

int n, m, k, d[205][205];

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]);
            }
}

int main()
{
    cin >> n >> m >> k;
    
    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] = 0x3f3f3f3f;
        }
    
    for (int i = 1; i <= m; ++ i )
    {
        int x, y, z;
        cin >> x >> y >> z;
        d[x][y] = min(d[x][y], z);
    }
    
    floyd();
    
    for (int i = 1; i <= k; ++ i )
    {
        int x, y;
        cin >> x >> y;
        if (d[x][y] >= 0x3f3f3f3f-100) cout << "impossible" << endl;
        else cout << d[x][y] << endl;
    }
    
    return 0;
}