最短路算法（floyed+Dijkstra+bellman-ford+SPFA）

最短路算法简单模板

一.floyed算法

首先对于floyed算法来说就是最短路径的动态规划解法，时间复杂度为O（n^3） 适用于图中所有点与点之间的最短路径的算法，一般适用于点n较小的情况。

Floyed算法有三层循环，循环的层次先后顺序也是比较重要的，分别为k ，i，j；因为dis[k][i][j]代表的是i节点到j节点的最短路如果中间经过节点k的话dis[k][i][j] =dis[k-1][i][k]+dis[k-1][k][j]；否则dis[k][i][j] = dis[k-1][i][j];所以说我们要求第k个节点的话就必须先把所有的k-1求出来。而此处的三维dis数组正如背包问题一样优化为二维数组。

对于任意两个节点i，j来说；要想从节点i到达节点j的话有两种情况：

1. 由i直接到达j
2. 由i经过若干个k节点到达j

所以dis[i][j] = min(dis[i][j],dis[i][k]+dis[k][j])；

HDU 2544 最短路

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 const int INF = 0x3f3f3f;
 int n, m, mp[][];
 void floyed()
 {
     for (int k = ; k <= n; k++)
         for (int i = ; i <= n; i++)
             for (int j = ; j <= n; j++)
                 mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]);
 }
 int main()
 {
     ios::sync_with_stdio(false);
     while ((cin >> n >> m)&&n&&m) {
         memset(mp, INF, sizeof(mp));
         for (int a, b, c, i = ; i < m; i++) {
             cin >> a >> b >> c;
             mp[a][b] = mp[b][a] =  min(mp[a][b], c);
         }
         floyed();
         cout << mp[][n] << endl;
     }
     return ;
 }

二.Dijkstra算法

关于Dijkstra算法(贪心)的推断过程我就不详细的讲啦，我会的别人都已经讲完了而且还比我详细，在这里向大家推荐一篇写的不错的博客！https://www.cnblogs.com/nigang/p/3658990.html

这位博主讲的还是很详细的，图解也很清晰明了

下面我还是通过一个例题来讲解代码吧!（同floyed例题）

邻接矩阵的Dijkstra：

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 const int INF = 0x3f3f3f;
 int n, m, mp[][];
 int dis[], vis[];
 void Dijkstra()
 {
     for (int i = ; i <= n; i++) {
         vis[i] = ; dis[i] = mp[][i];
     }
     for (int i = ; i <= n; i++) {
         int cnt = INF, k;
         for (int j = ; j <= n; j++) {
             if (!vis[j] && dis[j] < cnt) {
                 cnt = dis[j];
                 k = j;
             }
         }
         vis[k] = ;
         for (int j = ; j <= n; j++) {
             if (!vis[j] && dis[j] > dis[k] + mp[k][j])
                 dis[j] = dis[k] + mp[k][j];
         }
     }
 }
 int main()
 {
     ios::sync_with_stdio(false);
     while ((cin >> n >> m)&&n&&m) {
         memset(mp, INF, sizeof(mp));
         for (int a, b, c, i = ; i < m; i++) {
             cin >> a >> b >> c;
             mp[a][b] = mp[b][a] =  min(mp[a][b], c);
         }
         Dijkstra();
         cout << dis[n] << endl;
     }
     return ;
 }

堆优化后的Dijkstra

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<bitset>
 #include<vector>
 #include<queue>

 using namespace std;
 const int INF =  << ;
 const int maxn = ;
 struct node{
     int to, cost;
     node() {}
     node(int a, int b) :to(a), cost(b) {}
     bool operator<(const node&a)const {
         if (cost == a.cost)return to < a.to;
         return cost > a.cost;
     }
 };
 vector<node>e[maxn];
 int n, m, dis[maxn];
 void Dijkstra(int s)
 {
     for (int i = ; i <= n; i++)dis[i] = INF;
     dis[s] = ;
     priority_queue<node>Q;
     Q.push(node(s, dis[s]));
     while (!Q.empty()) {
         node t = Q.top(); Q.pop();
         for (int i = ; i < e[t.to].size(); i++) {
             int tmp = e[t.to][i].to;
             if (dis[tmp] > t.cost + e[t.to][i].cost) {
                 dis[tmp] = t.cost + e[t.to][i].cost;
                 Q.push(node(tmp, dis[tmp]));
             }
         }
     }
 }
 int main()
 {
     ios::sync_with_stdio(false);
     while ((cin >> n >> m)&&(n&&m)) {
         for (int i = ; i <= n; i++)e[i].clear();
         for (int a, b, c, i = ; i < m; i++) {
             cin >> a >> b >> c;
             e[a].push_back(node(b, c));
             e[b].push_back(node(a, c));
         }
         Dijkstra();
         cout << dis[n] << endl;
     }
     return ;
 }

三.bellman-ford算法

当路径当中出现负权值边的时候Dijkstra算法将不再适用，因为dijkstra由于是贪心的，每次都找一个距源点最近的点，然后将该距离定为这个点到源点的最短路径，但如果存在负权边，那就有可能先通过并不是距源点最近的一个次优点，而是这一个负权值边，所求出的结果可能就不是最短距离了。

算法讲解https://blog.csdn.net/niushuai666/article/details/6791765

模板：无向图。有向图的话边只需要加一次即可

 #include<iostream>
 #include<algorithm>

 using namespace std;
 const int INF =  << ;
 const int maxn = ;
 struct node {
     int from, to, cost;
     node() {}
     node(int a, int b, int c) :from(a), to(b), cost(c) {}
 }e[maxn<<];
 int n, m, dis[];
 bool bellman_ford()
 {
     for (int i = ; i <= n; i++)dis[i] = INF;
     dis[] = ;
     for (int i = ; i < n; i++) {
         int flag = ;
         for (int j = ; j <=  * m; j++) {
             if (dis[e[j].to] > dis[e[j].from] + e[j].cost) {
                 dis[e[j].to] = dis[e[j].from] + e[j].cost;
                 flag = ;
             }
         }
         if (!flag)return true;
     }
     for (int j = ; j <= m; j++)
         if (dis[e[j].to] > dis[e[j].from] + e[j].cost)
             return false;
     return true;
 }
 int main()
 {
     ios::sync_with_stdio(false);
     while ((cin >> n >> m)&&n&&m) {
         for (int a, b, c, i = ; i <= m; i++) {
             cin >> a >> b >> c;
             e[i] = node(a, b, c);
             e[i + m] = node(b, a, c);
         }
         bellman_ford();
         cout << dis[n] << endl;
     }
     return ;
 }

四. SPFA 算法<--bellman-ford算法的优化

一篇清晰的算法过程的讲解！https://www.cnblogs.com/bofengyu/p/5004398.html

代码模板如下

例题：POJ 2387

http://poj.org/problem?id=2387

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #include<queue>

 using namespace std;
 const int maxn = ;
 const int INF = 0x3f3f3f3f3f;
 int n, m;
 struct node{
     int to, cost;
     node() {}
     node(int a, int b) :to(a), cost(b) {}
 };
 vector<node> e[maxn];
 int vis[maxn], f[maxn], dis[maxn];
 void SPFA(int s)
 {
     for (int i = ; i < maxn; i++) {
         vis[i] = ; f[i] = ;
         dis[i] = INF;
     }
     dis[s] = ;
     vis[s] = ; f[s]++;
     queue<int>Q;
     Q.push(s);
     while (!Q.empty()) {
         int t = Q.front(); Q.pop();
         vis[t] = ;
         for (int i = ; i < e[t].size(); i++) {
             int tmp = e[t][i].to;
             if (dis[tmp] > dis[t] + e[t][i].cost) {
                 dis[tmp] = dis[t] + e[t][i].cost;
                 if (!vis[tmp]) {
                     vis[tmp] = ;
                     Q.push(tmp);
                     if (++f[tmp] > n)return;
                 }
             }
         }
     }
     return;
 }
 int main()
 {
     ios::sync_with_stdio(false);
     while (cin >> m >> n) {
         for (int a, b, c, i = ; i <= m; i++) {
             cin >> a >> b >> c;
             e[a].push_back(node(b, c));
             e[b].push_back(node(a, c));
         }
         SPFA();
         cout << dis[n] << endl;
     }
     return ;
 }