DIJ&SPFA-Til the Cows Come Home POJ - 2387

Til the Cows Come Home POJ - 2387

用dij和spfa写了做个对比，看了一篇很好的文章对这两个算法有了更好的理解**《Dijkstra+heap和SPFA的区别》**
题目：
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.

题意：
最短路的模板题，输入边的数量T，点的数量N，各条边的顶点和权值，求点1到N的最短距离。
用dijkstra和spfa都写了一下做个对比。

代码：

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<string>
#define P pair<int,int>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=1e4+5;
int head[maxn],d[maxn];
bool vis[maxn];
int T,N,k=0,s,e;
struct node
{
    int v,next,w;
}a[maxn];
void add(int u,int v,int w)
{
    a[++k].next=head[u];
    a[k].v=v;
    a[k].w=w;
    head[u]=k;
}
void dij()
{
    memset(d,inf,sizeof(d));
    memset(vis,false,sizeof(vis));
    d[s]=0;
    priority_queue<P,vector<P>,greater<P> > q;//greater---小根堆
    q.push(make_pair(0,s));
    while(q.size())
    {
        int u=q.top().second;
        q.pop();
        if(vis[u]) continue;
        vis[u]=true;
        for(int i=head[u];i;i=a[i].next)
        {
            int v=a[i].v,w=a[i].w;
            if(d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                q.push(make_pair(d[v],v));//若未注明greater小根堆，那么入队时权值为-d[v]
                //vis[v]=true; 这里一开始理解错了，入队的点还未考虑过，所以不能标记
            }
        }
    }
}

void spfa()
{
    memset(d,inf,sizeof(d));
    memset(vis,false,sizeof(vis));
    d[s]=0;
    queue<int> q;
    q.push(s);
    while(q.size())
    {
        int u=q.front();
        q.pop();
        //if(vis[u]) continue;//区别于dij，spfa是考虑边，点u出队后仍然可能被考虑继续松弛
        vis[u]=false;//所以要将u取消标记
        for(int i=head[u];i;i=a[i].next)
        {
            int v=a[i].v,w=a[i].w;
            if(d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                if(!vis[v])
                    q.push(v),vis[v]=true;
            }
        }
    }
}
int main()
{
    cin>>T>>N;
    for(int i=0;i<T;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
        add(v,u,w);
    }
    s=1,e=N;
    //dij();
    spfa();
    cout<<d[e];
    return 0;
}

收获：
优先队列的使用。