Til the Cows Come Home（三种最短路算法对比）

最新推荐文章于 2021-01-13 21:43:40 发布

转载最新推荐文章于 2021-01-13 21:43:40 发布 · 109 阅读

本内容遵循CC 4.0 BY-SA版权协议

原文链接：http://www.cnblogs.com/liuyongliu/p/11206332.html

本文通过一个具体的示例问题——牛回家的最短路径问题，介绍了三种不同的图算法实现：Dijkstra算法、Bellman-Ford算法及SPFA算法。这三种算法分别适用于不同情况下的最短路径求解，Dijkstra算法适用于所有边权为正的情况，Bellman-Ford算法能够处理负权边但不能有负权环，而SPFA算法则是一种基于队列优化的Bellman-Ford算法。

例题：

Til the Cows Come Home

https://vjudge.net/problem/POJ-2387

Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep, so she wants to get back as quickly as possible.

Farmer John's field has N (2 <= N <= 1000) landmarks in it, uniquely numbered 1..N. Landmark 1 is the barn; the apple tree grove in which Bessie stands all day is landmark N. Cows travel in the field using T (1 <= T <= 2000) bidirectional cow-trails of various lengths between the landmarks. Bessie is not confident of her navigation ability, so she always stays on a trail from its start to its end once she starts it.

Given the trails between the landmarks, determine the minimum distance Bessie must walk to get back to the barn. It is guaranteed that some such route exists.

Input

* Line 1: Two integers: T and N

* Lines 2..T+1: Each line describes a trail as three space-separated integers. The first two integers are the landmarks between which the trail travels. The third integer is the length of the trail, range 1..100.

Output

* Line 1: A single integer, the minimum distance that Bessie must travel to get from landmark N to landmark 1.

Sample Input

Sample Output

Hint

INPUT DETAILS:

There are five landmarks.

OUTPUT DETAILS:

Bessie can get home by following trails 4, 3, 2, and 1.

代码一：单纯Dijkstra（边权必须为正）
代码二：Bellman-Ford算法（可解负权图）
代码三：算法二queue优化版，也称SPFA（此算法一般较为高效）

代码：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int inf=0x3f3f3f3f;
int T,N;
int B[1006];
int d[1006];
struct node{
    int v;
    int edge;
    node(int _v,int _e):v(_v),edge(_e){}
};
vector<node>G[1006];

struct No{
    int d,num;
    bool operator < (const No& ret) const{
        return d>ret.d;
    }
};

void Dijkstra()
{
    priority_queue<No>Q;
    for(int i=1;i<=N;i++) d[i]= (i==N?0:inf);
    Q.push((No){0,N});
    while(!Q.empty())
    {
        No x=Q.top();    Q.pop();
        if(B[x.num]) continue;
        B[x.num]=1;
        for(int i=0;i<G[x.num].size();i++)//松弛操作 
        {
            d[G[x.num][i].v]=min(d[G[x.num][i].v],d[x.num]+G[x.num][i].edge);
            Q.push((No){d[G[x.num][i].v],G[x.num][i].v});
        }
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    cin>>T>>N;
    while(T--)
    {
        int x,y,l;
        cin>>x>>y>>l;
        if(x==y) continue;
        G[x].push_back(node(y,l));
        G[y].push_back(node(x,l));
    }
    Dijkstra();
    cout<<d[1]<<endl;
    return 0;
}

Dijkstra

Dijkstra

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int inf=0x3f3f3f3f;
int T,N;
int B[1006];
int d[1006];
struct node{
    int v;
    int edge;
    node(int _v,int _e):v(_v),edge(_e){}
};
vector<node>G[1006];

bool Bell()
{
    for(int i=1;i<=N;i++) d[i]= (i==N?0:inf);
    
    for(int i=0;i<N-1;i++)//n-1轮 
    {
        for(int j=1;j<=N;j++)
        {
            for(int k=0;k<G[j].size();k++)
            {
                d[G[j][k].v]=min(d[G[j][k].v],d[j]+G[j][k].edge);
            }
        }
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    cin>>T>>N;
    while(T--)
    {
        int x,y,l;
        cin>>x>>y>>l;
        if(x==y) continue;
        G[x].push_back(node(y,l));
        G[y].push_back(node(x,l));
    }
    Bell();
    cout<<d[1]<<endl;
    return 0;
}

Bellman-Ford版本

Bellman-Ford算法

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int inf=0x3f3f3f3f;
int T,N;
int d[1006];
struct node{
    int v,edge;
    node(int _v,int _e):v(_v),edge(_e){}
};

vector<node>G[1006];
bool isin[1006];//判断改点还在不在Q中
int numin[1006];//判断改点加入Q几次 

void SPFA()
{
    for(int i=1;i<=N;i++) d[i]= (i==N?0:inf);
    queue<int>Q;
    Q.push(N);
    isin[N]=1;    numin[N]++;
    while(!Q.empty())
    {
        int u=Q.front();    Q.pop();    isin[u]=0;
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i].v;
            int dis=G[u][i].edge;
            if(d[v]>(d[u]+dis)){
                d[v]=d[u]+dis;
                if(isin[v]==0){
                    Q.push(v);
                    isin[v]=1;    numin[v]++;
                    if(numin[v]>N-1) return ;//大于N-1次，有可达负环，无解 
                }
            }
        }
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    cin>>T>>N;
    while(T--)
    {
        int x,y,l;
        cin>>x>>y>>l;
        G[x].push_back(node(y,l));
        G[y].push_back(node(x,l));
    }
    SPFA();
    cout<<d[1]<<endl; 
    return 0;
}

SPFA队列优化版

SPFA队列优化版

转载于:https://www.cnblogs.com/liuyongliu/p/11206332.html