Til the Cows Come Home

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.

这道题目是找最短路，单源最短路径的典型题目，运用了迪杰斯特拉算法。
、

#include<stdio.h>
#include<string.h>
#include<iostream>
#define INF 0x3f3f3f3f
using namespace std;
int mp[2006][2006],dis[2006],book[2006],n,m;

void dijkstra(int v0)
{
	for(int i=1;i<=m;i++)//遍历所有的点，得出从起点的各个边
	{
		dis[i]=mp[v0][i];
	}
	book[v0]=1;

	for(int i=0;i<m-1;i++)//遍历除开始节点外的所有的点的数目
	{                     //就是需要n-1次的寻找最小权值，就是需要选择剩下的所有节点
		int minn=INF,u;

		for(int j=1;j<=m;j++)//在所有的到起点的距离的边里找出最小权值的边
		{                   //因为不知道有从它出来有多少条边，因此全都遍历一遍，
			if(book[j]==0 && dis[j]<minn)//是从起点到未走过的指定点的最短值，是选择边的最短值
			{//而且设定就是为dis[]就是起点所有节点的距离，就算没有权值也可以说是无穷大
				minn=dis[j];
				u=j;
			}
		}
		book[u]=1;

		for(int j=1;j<=m;j++)//更新到那个节点的最小的距离值
		{
			if(book[j]==0 && dis[u]+mp[u][j]<dis[j])
			{
				dis[j]=dis[u]+mp[u][j];
			}
		}
	}
}

int main()
{
	while(cin>>n>>m)
	{
	    memset(dis,INF,sizeof(dis));//把dis数组附最大值（88不是十进制的88，其实很大）
	    memset(book,0,sizeof(book));
	    memset(mp,INF,sizeof(mp));
		for(int i=1;i<=m;i++)
		{
			for(int j=1;j<=m;j++)
			{
				if(i==j) mp[i][j]=0;
				else mp[i][j]=INF;
			}
		}
		int a,b,c;
		for(int i=0;i<n;i++)
		{
			//scanf("%d%d%d",&u,&v,&w);
			cin>>a>>b>>c;
			if(c<mp[a][b])
            mp[a][b]=mp[b][a]=c;
		}
		//int first,second;
		//scanf("%d%d",&s,&t);
		//cin>>first>>second;
		//first--;
		//second--;
		dijkstra(1);

		//if(dis[second]==INF) cout<<"-1"<<endl;
		//else
		cout<<dis[m]<<endl;
	}
	return 0;
}

/*

6 5
1 2 5
1 3 8
2 3 1
2 4 3
4 5 7
2 5 2
1 5
-1

#include<stdio.h>
#include<string.h>
#include<iostream>
#define INF 0x3f3f3f3f
using namespace std;
int mp[1010][1010],dis[1010],book[1010],n,m;

void dijkstra(int v0)
{
	for(int i=1;i<=n;i++)//遍历所有的点，得出从起点的各个边
	{
		dis[i]=mp[v0][i];
	}
	book[v0]=1;

	for(int i=0;i<n-1;i++)//遍历除开始节点外的所有的点的数目
	{                     //就是需要n-1次的寻找最小权值，就是需要选择剩下的所有节点
		int minn=INF,u;

		for(int j=1;j<=n;j++)//在所有的到起点的距离的边里找出最小权值的边
		{                   //因为不知道有从它出来有多少条边，因此全都遍历一遍，
			if(book[j]==0 && dis[j]<minn)//是从起点到未走过的指定点的最短值，是选择边的最短值
			{//而且设定就是为dis[]就是起点所有节点的距离，就算没有权值也可以说是无穷大
				minn=dis[j];
				u=j;
			}
		}
		book[u]=1;

		for(int j=1;j<=n;j++)//更新到那个节点的最小的距离值
		{
			if(book[j]==0 && dis[u]+mp[u][j]<dis[j])
			{
				dis[j]=dis[u]+mp[u][j];
			}
		}
	}
}

int main()
{
	while(cin>>n>>m)
	{
	    memset(dis,INF,sizeof(dis));//把dis数组附最大值（88不是十进制的88，其实很大）
	    memset(book,0,sizeof(book));
	    memset(mp,INF,sizeof(mp));
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(i==j) mp[i][j]=0;
				else mp[i][j]=INF;
			}
		}
		int a,b,c;
		for(int i=0;i<m;i++)
		{
			//scanf("%d%d%d",&u,&v,&w);
			cin>>a>>b>>c;
			if(c<mp[a][b])
            mp[a][b]=mp[b][a]=c;
		}
		int first,second;
		//scanf("%d%d",&s,&t);
		cin>>first>>second;
		//first--;
		//second--;
		dijkstra(first);

		if(dis[second]==INF)
        cout<<"-1"<<endl;
		else
		cout<<dis[second]<<endl;
	}
	return 0;
}

/*

5 6
1 2 5
1 3 8
2 3 1
2 4 3
4 5 7
2 5 2
1 5
7




*/