图上最短路(Dijkstra, spfa)

单源最短路径

题目描述

如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。

输入输出格式

输入格式：

第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。

接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。

输出格式：

一行，包含N个用空格分隔的整数，其中第i个整数表示从点S出发到点i的最短路径长度（若S=i则最短路径长度为0，若从点S无法到达点i，则最短路径长度为2147483647）

输入输出样例

输入样例

输出样例

单源最短路（Single-Source Shortest Paths, SSSP）

先上Dijkstra算法

Dikstra 算法适用于边权为正的情况。主要想法是：将一个点走一步能到达的所有结点都放进队列里，并从队列里选择源点到该点路径最短的结点出队。这样就保证出队的结点一定是源点到该点的最短路。那么就能确定放进队列的每一个结点不仅要有该结点的编号，也要有源点到该结点的距离，所以可以用结构体来实现。队列中出队的必须是最小的，那么就可以用优先队列实现。所以开一个结构体优先队列。

 #include<cstdio>
 #include<cmath>
 #include<iostream>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<vector>
 using namespace std;
 const int maxn = 1e4 + ;
 const int INF = ;
 struct Grap
 {
     int num, cost;    //num点编号，cost到该点距离
     bool operator < (const Grap& other)const
     /*优先队列出队的原本是最大的，而我们期望的是最小的,所
     以重载小于号，不仅要兼容结构体，还要使逻辑相反 */
     {
         return cost > other.cost;
     }
 };
 vector<int>v[maxn];
 vector<int>c[maxn];
 int n, m, k, vis[maxn], dis[maxn];
 void dijkstra(int k)
 {
     for(int i = ; i < maxn; ++i)
         dis[i] = INF;
     /*初始化设为无穷，同时也代表了源点无法到达的点
     的最短路径长度就是无穷*/
     memset(vis, , sizeof(vis));
     priority_queue<Grap>q;
     q.push((Grap){k, });
     dis[k] = ;
     while(!q.empty())
     {
         Grap now = q.top(); q.pop();
         int node = now.num;
         if(vis[node]) continue;
         /*如果该点已经出队，那到这个点的路径长度一定是最短路。为了防止
         结点的重复扩展，如果发现新取出来的结点曾经被取出来过，应该直接
         把它扔掉，所以开一个数组记录。 */
         vis[node] = ;
         for(int i = ; i < v[node].size(); ++i)
         {
             if(dis[v[node][i]] > dis[node] + c[node][i])
             {
                 dis[v[node][i]] = dis[node] + c[node][i];

                 q.push((Grap){v[node][i], dis[v[node][i]]});
             }
         }
     }
 }
 int main()
 {
     scanf("%d%d%d", &n, &m, &k);
     for(int i = ; i < m; ++i)
     {
         int a, b, cost; scanf("%d%d%d", &a, &b, &cost);
         v[a].push_back(b); c[a].push_back(cost);    //用vector建图
     }
     dijkstra(k);
     for(int i = ; i <= n; ++i) printf("%d%s",dis[i], i == n ? "\n" : " ");
     return ;
 }

再上一个spfa算法

spfa算法不仅可以求最短路，也可以判断一个图中存不存在负圈。在这个算法中，一个结点可能多次入队（出队），最多入队 n 次（结点个数次），而当超过 n 次时，就证明一定存在负圈。

 #include <cstdio>
 #include<iostream>
 #include<cmath>
 #include<queue>
 #include<vector>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 vector<int>v[], c[];
 const int INF = ;
 int dis[];
 bool vis[];
 void spfa(int a)
 {
     for(int i = ; i < ; ++i) dis[i] = INF;
     dis[a] = ;
     memset(vis, , sizeof(vis));
     queue<int>q;q.push(a);
     while(!q.empty())
     {
         int now = q.front();q.pop();
         vis[now] = ;    //出队后去除标记
         for(int i = ; i < (int)v[now].size(); ++i)
         {
             if(dis[now] + c[now][i] < dis[v[now][i]])
             {
                 dis[v[now][i]] = dis[now] + c[now][i];
                 if(!vis[v[now][i]])
                     {q.push(v[now][i]); vis[v[now][i]] = ;}
             }
         }
     }
 }
 int main()
 {
     int n, m, s;
     scanf("%d%d%d", &n, &m, &s);
     for(int i = ; i < m; ++i)
     {
         int f, g, w;
         scanf("%d%d%d", &f, &g, &w);
         v[f].push_back(g);c[f].push_back(w);
     }
     spfa(s);
     for (int i = ; i <= n; i++) printf("%d%c", dis[i], i == n ? '\n' : ' ');
 }