POJ-2387Til the Cows Come Home,最短路坑题，dijkstra+队列优化

Til the Cows Come Home

Time Limit: 1000MS		Memory Limit: 65536K

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

Description

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.

Source

USACO 2004 November

最短路A的第一道题，做了一天还是看讨论区才做出来的，，不过不看讨论区准被坑死。

题意很简单，n个点，t条路，求1到n的最短路，用dijkstra就可以了，其他的也一样，只不过没想到会有重边的情况，这样用弗洛伊德算法直接过，但对于迪杰斯特拉稍加修改即可以；还需注意的是无向图，这样用邻接矩阵的方法就可以了；但开始提交老是RE，看讨论区才发现这个神坑，先输入t再输入n,无限RE无限WA。。。

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1000+10;
int v[N];
int d[N],w[N][N];
int main()
{
    int n,t,i,j;
    while(~scanf("%d%d",&t,&n))
    {
        memset(v,0,sizeof(v));
        for(i=1;i<=n;i++)
            d[i]=(i==1?0:INF);//d[i]表示初始点到i点的最短距离，这里先初始化；
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
            w[i][j]=INF;//表示这条边不存在；
            int a,b,c;
        for(i=0;i<t;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            w[a][b]=w[b][a]=min(w[a][b],c);//邻接矩阵解决重边问题；
        }
        for(i=1;i<=n;i++)
        {
            int x,m=INF;
            for(j=1;j<=n;j++)
                if(!v[j]&&d[j]<=m)
                m=d[x=j];
            v[x]=1;//标记已访问过；
            for(j=1;j<=n;j++)
                d[j]=min(d[j],d[x]+w[x][j]);//这里蛮好懂的，整个算法看起来不难，但要灵活运用就不简单了；
        }
        printf("%d\n",d[n]);
    }
    return 0;
}

以下内容续写于2016.9.3 22：30；

花了几天时间理解了用对列优化的dijstra,整理出了适合自己的代码。具体要完全靠自己实现是那么难，嗯，继续加油！

此题由于有重边的情况，想不出什么方法解决，所以开了二维邻接矩阵来存图，具体来看代码加详解：

typedef long long ll;
const int INF=0x3f3f3f3f;
const int N=10000+10;
int n,m,s,e;
int d[N],vis[N],w[N][N];
vector<int>g[N];//存邻接点；
typedef pair<int,int>pii;//优先队列pair型优先比较第一维；
void dij()
{
    memset(vis,0,sizeof(vis));
    for(int i=1; i<=n; i++) d[i]=i==1?0:INF;
    priority_queue<pii,vector<pii>,greater<pii> >q;
    while(!q.empty()) q.pop();
    q.push(make_pair(d[1],1));//将起点加入队列；
    while(!q.empty())//时间复杂度mlog(m);
    {
        pii temp=q.top();
        q.pop();
        int u=temp.second;
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=0; i<g[u].size(); i++)
            if(d[g[u][i]]>d[u]+w[u][g[u][i]])
            {
                d[g[u][i]]=d[u]+w[u][g[u][i]];
                q.push(make_pair(d[g[u][i]],g[u][i]));//将邻接点加入队列，有点类似广搜。
            }
    }
    printf("%d\n",d[n]);
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        for(int i=1; i<N; i++) g[i].clear();
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                w[i][j]=i==j?0:INF;
        int u,v,c;
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&u,&v,&c);
      w[v][u]=w[u][v]=w[u][v]==INF?c:min(w[u][v],c);//邻接矩阵是为了避免有重边的情况，但增加了空间复杂度；
            g[u].push_back(v);
            g[v].push_back(u);//此条语句适用双向边的情况；
        }
//        scanf("%d%d",&s,&e);//起点终点；
        dij();
    }
    return 0;
}