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

例题：

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

5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100

Sample Output

90

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

#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版本

#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队列优化版