求出有n(1 < n < 600)个结点有向图中，结点1到结点n的最短路径。

Input
第一行有2个整数n和m(0 < m <= n*(n-1)/2)，接下来m行每行有三个整数u,v,w结点u到v之间有一条权为w的边(w<1000000)。

Output
输出结点1到结点n之间的最短路径，如果1到n之间不存在路径，输出 -1。

Sample Input
3 3
1 2 10
2 3 15
1 3 30

题目分析：dijkstra单元最短路径。

一.最短路径的最优子结构性质

该性质描述为：如果P(i,j)={Vi….Vk..Vs…Vj}是从顶点i到j的最短路径，k和s是这条路径上的一个中间顶点，那么P(k,s)必定是从k到s的最短路径。下面证明该性质的正确性。

   假设P(i,j)={Vi….Vk..Vs…Vj}是从顶点i到j的最短路径，则有P(i,j)=P(i,k)+P(k,s)+P(s,j)。而P(k,s)不是从k到s的最短距离，那么必定存在另一条从k到s的最短路径P'(k,s)，那么P'(i,j)=P(i,k)+P'(k,s)+P(s,j)<P(i,j)。则与P(i,j)是从i到j的最短路径相矛盾。因此该性质得证。

二.Dijkstra算法

   由上述性质可知，如果存在一条从i到j的最短路径(Vi…..Vk,Vj)，Vk是Vj前面的一顶点。那么(Vi…Vk)也必定是从i到k的最短路径。为了求出最短路径，Dijkstra就提出了以最短路径长度递增，逐次生成最短路径的算法。譬如对于源顶点V0，首先选择其直接相邻的顶点中长度最短的顶点Vi，那么当前已知可得从V0到达Vj顶点的最短距离dist[j]=min{dist[j],dist[i]+matrix[i][j]}。根据这种思路，

假设存在G=<V,E>，源顶点为V0，U={V0},dist[i]记录V0到i的最短距离，path[i]记录从V0到i路径上的i前面的一个顶点。

1.从V-U中选择使dist[i]值最小的顶点i，将i加入到U中；

2.更新与i直接相邻顶点的dist值。(dist[j]=min{dist[j],dist[i]+matrix[i][j]})

3.知道U=V，停止。

三，重用邻接矩阵实现，这对于稀疏图来说效率往往会很低，常用的优化方法有1，用邻接表存储,2用二叉堆优化每次选择最短路径的速度。下面分别给出两种代码。

版本一：常用邻接矩阵实现方法：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

int cost[605][605],low[605];//cost为邻接矩阵，low为当前到源点的最短距离
bool vis[605];

const int maxn=1000000;

int main()
{
    int n,m,i,j,k;
    memset(vis,false,sizeof(vis));
    while(~scanf("%d%d",&n,&m)){
        for(i=0;i<605;++i)
            for(j=0;j<605;++j)
                cost[i][j]=maxn;
        for(i=0;i<m;++i){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            cost[a][b]=c;
        }

        for(i=1;i<=n;++i){
            low[i]=cost[1][i];
            vis[i]=false;
        }
        vis[1]=true;
        for(i=2;i<=n;++i){
            int minn=1<<30;
            for(j=1;j<=n;++j){//选择当前最近点，这里可用堆优化
                if(!vis[j] && low[j]<minn){
                    minn=low[j];
                    k=j;
                }
            }
            vis[k]=true;//将当前的加入以最优集合，之后不再对这点判断
            for(j=1;j<=n;++j){//更新
                if(!vis[j] && low[k]+cost[k][j]<low[j]){
                    low[j]=low[k]+cost[k][j];
                }
            }
        }
        if(low[n]>=maxn)
            printf("-1\n");
        else
            printf("%d\n",low[n]);
    }
    return 0;
}

版本二：使用二叉堆和邻接表，对大数据的稀疏图效果更好。

#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
const int MAXN=1000000;
vector<int> g[605];//邻接表，g[i]一次存储与i邻接的边的下标，方便快速查找
bool vis[605];//标记数组
int low[605],n,m;//当前最短距离
struct Edge{//边类
    int from,to,dis;
};
vector<Edge> edge;//存储边的情况
struct Node{//用于优先队列中的节点
    int d,u;
    bool operator<(const Node &b)const{
        return this->d>b.d;
    }
};
void dijkstra(){
    for(int i=0;i<=n;++i) low[i]=MAXN;//初始化
    low[1]=0;
    memset(vis,false,sizeof(vis));
    priority_queue<Node> q;
    q.push((Node){0,1});
    while(!q.empty()){
        Node x=q.top();//快速找当前最短距离点
        q.pop();
        int u=x.u;
        if(vis[u]) continue;//如果该点已经为最优，则忽略
        vis[u]=true;
        for(int i=0;i<g[u].size();++i){//更新
            Edge &e=edge[g[u][i]];
            if(low[e.to]>low[u]+e.dis){
                low[e.to]=low[u]+e.dis;
                q.push((Node){low[e.to],e.to});
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        edge.push_back((Edge){a,b,c});
        g[a].push_back(edge.size()-1);
    }
    dijkstra();
    if(low[n]>=MAXN) printf("-1\n");
    else printf("%d\n",low[n]);
    return 0;
}