模板--Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法

Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法汇总

最短路

Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗?

 

Input 输入包括多组数据。每组数据第一行是两个整数N、M(N<=100,M<=10000),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1<=A,B<=N,1<=C<=1000),表示在路口A与路口B之间有一条路,我们的工作人员需要C分钟的时间走过这条路。

输入保证至少存在1条商店到赛场的路线。

 

Output 对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间  

Sample Input

   
    2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
   

 

Sample Output

   
    3
2
   

  具体算法思路见代码:

No. 1 Floyd

#include <bits/stdc++.h>
 #define endl "\n"
 #define inf 0x7fffffff
using namespace std;

const int MAXN = 100 + 7;

int n, m;
int dis[MAXN][MAXN];

void Init() {
        for(int i = 0; i <= n; ++i) {
                for(int j = 0; j <= n; ++j) {
                        i == j ? dis[i][j] = 0 : dis[i][j] = inf;
                }
        }
}

int main()
{
        ios::sync_with_stdio(false);
        while(cin >> n >> m) {
                if(!n && !m) break;
                Init();
                int u, v, w;
                for(int i = 1; i <= m; ++i) {
                        cin >> u >> v >> w;
                        dis[u][v] = min(w, dis[u][v]);
                        dis[v][u] = min(w, dis[v][u]);
                }

                /**************************************
                 *        Floyd O(n^3)
                 *      三行情书, for 循环中i, j, k
                 *      顺序不能变(k)
                 *      本质是动态规划,枚举状态,转移
                **************************************/

                for(int k = 1; k <= n; ++k) {
                        for(int i = 1; i <= n; ++i) {
                                for(int j = 1; j <= n; ++j) {
                                        if(dis[i][k] < inf && dis[k][j] < inf && dis[i][j] > dis[i][k] + dis[k][j]) {
                                                dis[i][j] = dis[i][k] + dis[k][j];
                                        }
                                }
                        }
                }

                cout << dis[1][n] << endl;
        }
        return 0;
}

No. 2 Dijkstra

/**********************************************************
 *           最短路Dijkstra算法  O(n^2)
 *   适用于求单源最短路,不适合带有负权的情形
 *   算法思想:从原点出发,每次找一个源点能到达的最短路
 *          径并找到该点将其标号,再从源点开始将所有
 *          点的距离依照
 *             dis[j] > dis[index] + gra[index][j]
 *          更新
 *   基于:最短路的子路也一定是最短路
 *********************************************************/
 #include <bits/stdc++.h>
 #define endl "\n"
 #define inf 0x7ffffff
using namespace std;

const int MAXN = 100 + 7;
int n, m;
int dis[MAXN], vis[MAXN], gra[MAXN][MAXN];

void Init() {
        for(int i = 0; i <= n; ++i) {
                vis[i] = 0;
                for(int j = 0; j <= n; ++j) {
                        gra[i][j] = inf;
                }
        }
}

void Dijkstra(int u) {
        int mindis = inf, index;
        vis[u] = 1, dis[u] = 0;
        for(int i = 1; i <= n; ++i) {
                dis[i] = gra[u][i];
        }
        for(int i = 1; i <= n; ++i) {
                mindis = inf;
                for(int j = 1; j <= n; ++j) {
                        if(!vis[j] && dis[j] < mindis) {
                                mindis = dis[j];
                                index = j;
                        }
                }
                vis[index] = 1;
                for(int j = 1; j <= n; ++j) {
                        if(!vis[j] && dis[index] + gra[index][j] < dis[j]) {
                                dis[j] = dis[index] + gra[index][j];
                        }
                }
        }
}

int main()
{
        ios::sync_with_stdio(false);
        while(cin >> n >> m) {
                if(!n && !m) break;
                Init();
                int u, v, w;
                for(int i = 0; i < m; ++i) {
                        cin >> u >> v >> w;
                        gra[u][v] = min(gra[u][v], w);
                        gra[v][u] = min(gra[v][u], w);
                }
                Dijkstra(1);
                cout << dis[n] << endl;
        }
        return 0;
}

No. 3 Bellman-Ford

/*******************************************************
 *              Bellman-Ford  O(V*E)
 *      使用条件更广泛,可处理带环,负权,负环的问题
 *          可求得单元最短路并求出路径反向输出
 *      算法伪码:
 *      BELLMAN-FORD(G, w, s)
 *      1  INITIALIZE-SINGLE-SOURCE(G, s)
 *      2  for i ← 1 to |V[G]| - 1      // 最多n-1次松弛
 *      3       do for each edge (u, v) ∈ E[G]
 *      4              do RELAX(u, v, w)
 *      5  for each edge (u, v) ∈ E[G]
 *      6       do if d[v] > d[u] + w(u, v)
 *      7             then return FALSE
 *      8  return TRUE
 *      算法思想:
 *      首先初始化所有dis[i] = inf
 *      对于每一条边e(u, v),
 *      如果
 *              dis[u] + w(u, v) < dis[v]
 *      则令
 *              dis[v] = dis[u]+w(u, v)
 *      w(u, v)为边e(u,v)的权值;
 *      为了检测图中是否存在负环路,即权值之和小于0的环路。
 *      松弛完成后,对于每一条边e(u, v),如果存在
 *              dis[u] + w(u, v) < dis[v]的边,
 *      则图中存在负环路,即是说该图无法求出单源最短路径。
 *      否则数组dis[n]中记录的就是源点s到各顶点的最短路径长度。
 *
 *      PS:无向图可用反向建边的方式
 *
 ******************************************************/
 #include <bits/stdc++.h>
 #define endl "\n"
 #define inf 0x7fffffff
using namespace std;

const int MAXN = 100 + 7;

struct Edge {
        int u, v, w;
}edge[MAXN * MAXN * 2];

int dis[MAXN], n, m;

void Init() {
        for(int i = 1; i <= 2*m; ++i) {
                edge[i].w = inf;
        }
        for(int i = 0; i <= n; ++i) {
               dis[i] = inf;
        }
}

bool BellmanFord(int u) {
        dis[u] = 0;
        for(int i = 1; i < n; ++i) {
                for(int j = 1; j <= 2*m; ++j) {
                        if(dis[edge[j].u] < inf) {
                                dis[edge[j].v] = min(dis[edge[j].v], dis[edge[j].u] + edge[j].w);
                        }
                }
        }
        bool flag = true;
        for(int i = 1; i <= 2*m; ++i) {
                if(dis[edge[i].v] > dis[edge[i].u] + edge[i].w) {
                        flag = false;
                        break;
                }
        }
        return flag;
}

int main()
{
        ios::sync_with_stdio(false);
        while(cin >> n >> m) {
                if(!n && !m) break;
                Init();
                int u, v, w;
                for(int i = 1; i <= m; ++i) {
                        cin >> u >> v >> w;
                        edge[i].u = u;
                        edge[i].v = v;
                        //cout << edge[i].w << endl;
                        edge[i].w = min(w, edge[i].w);
                        edge[i+m].u = v;
                        edge[i+m].v = u;
                        edge[i+m].w = min(w, edge[i+m].w);
                }
                BellmanFord(1);
                cout << dis[n] << endl;
        }
        return 0;
}

No. 4 Spfa (亦即优化的Bellman-Ford)

/*******************************************************
 *              spfa   O(k * E)  (k 一般 <= 2)
 *      算法思想:spfa其实就是改进的Bellman-Ford
 *          这里将由i发出的能直接到达的点存放在
 *          link[i]里,用bfs进行松弛操作,将在队
 *          列里面的点标记,每次将队首元素出列,
 *          根据link[v]遍历与v连接的点并进行松弛
 *          操作,遍历完所有点后就得到了最短路(存在)
 *          再开一个cnt数组,cnt[i]表示i进入队列
 *          的次数,当i>n时,存在负环,无最短路
 * #define endl "\n"
 #define inf 0x7fffffff          // 注意inf的条件
using namespace std;

const int MAXN = 100 + 7;
int gra[MAXN][MAXN], vis[MAXN], dis[MAXN], cnt[MAXN];
vector< vector<int> > link(MAXN);     // link[i]中存由i能直接到达的点的编号
int n, m;
void Init() {
        for(int i = 0; i < MAXN; ++i) { // 多重vector不能直接link.clear()
                link[i].clear();
        }
        for(int i = 0; i <= n; ++i) {
                dis[i] = inf;
                cnt[i] = vis[i] = 0;
        }
        for(int i = 0; i <= n; ++i) {
                for(int j = 0; j <= n; ++j) {
                        i == j ? gra[i][j] = 0 : gra[i][j] = inf;
                }
        }
}

bool spfa(int u) {
        dis[u] = 0;
        cnt[u] = vis[u] =  1;             // vis代表在不在队列内
        queue<int> q;
        q.push(u);
        while(!q.empty()) {
                int v = q.front();
                vis[v] = 0;     // 每次队首元素出队列就将vis[v]置零
                q.pop();
                for(int i = 0; i < link[v].size(); ++i) {       // 由v指向的所有点进行松弛操作

                        if(dis[v] < inf && dis[link[v][i]] > dis[v] + gra[v][link[v][i]]) {
                                dis[link[v][i]] = dis[v] + gra[v][link[v][i]];
                                if(!vis[link[v][i]]) {
                                        q.push(link[v][i]);
                                        vis[link[v][i]] = 1;
                                        cnt[link[v][i]]++;
                                        if(cnt[link[v][i]] > n) return false;   // 存在负环
                                }
                        }
                }
        }
        return true;
}

int main()
{
        ios::sync_with_stdio(false);
        while(cin >> n >> m) {
                if(!n && !m) break;
                Init();
                int u, v, w;
                for(int i = 1; i <= m; ++i) {
                        cin >> u >> v >> w;
                        gra[u][v] = min(w, gra[u][v]);          // 无向图反向建边
                        gra[v][u] = min(w, gra[v][u]);
                        link[u].push_back(v);
                        link[v].push_back(u);
                }
                spfa(1);
                cout << dis[n] << endl;
        }
        return 0;
}

    原文作者:Bellman - ford算法
    原文地址: https://blog.csdn.net/qq_38386316/article/details/76397678
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞