hdu 2544最短路dijkstra

                                          最短路

                                         Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
                                                     Total Submission(s): 16861 Accepted Submission(s): 7169

Problem Description

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

Output

对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input

   
   
   
   

    
    
    
    2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
   
   
   
   

Sample Output

   
   
   
   

    
    
    
    3
2
   
   
   
   

 

代码：dijkstra

 

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
int v[1001];
int map[1001][1001];
int d[1001];
#define INF 9999999
void dijkstra(int s,int n)
{
	int i;
	int j;
	int x;
	int m;
	memset(v,0,sizeof(v));
	memset(d,0x3f,sizeof(d));
	d[s] = 0;
	//v[s] = 1;
	for(i=1;i<=n;i++)
	{
		m = INF;
		for(j=1;j<=n;j++)
		{
			if(!v[j]&&d[j]<=m)
			{
				x = j;
				m = d[j];
			}
		}
		v[x] = 1;
		for(j=1;j<=n;j++)
		{
			if(d[j]>d[x]+map[x][j])
			{
				d[j] = d[x]+map[x][j];
			}
		}
	}
}

int main() {
	int  i,n,m,s,w,o,p,t;
	while(~scanf("%d%d",&n,&m)) {
		if(0==n&&0==m) break;
		memset(map,0x3f,sizeof(map));
		for (i=0; i<m; i++) {
			scanf("%d%d%d",&p,&o,&t);
			map[o][p]=map[p][o]=t;
		}
		int c=INF;
		dijkstra(1,n);		
		printf("%d\n",d[n]);
	}
	return 0;
}

/*
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
*/

//多起点一个中终点的有向图最短路径hdu2680
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define INF 999999
#define sf scanf
#define pf printf
#define MAXN 1000
#define M 2002                                                                                                                #define N 1002    //这些看题目数据范围
int m,s;
int map[M][M];    //map[i][j]表示i到j的权值
int dis[N];        //dis[i] 表示原点s到i的距离
int visit[N];      //顶点是否被访问过
void dijkstra(int s,int n)
{
	int i,j,k = 0;
	int min;
	memset(visit,0,sizeof(visit));  //初始时都没被访问过
	for( i = 1; i <= n; i++ )
		dis[i]=map[s][i];
	dis[0] = 0;
	visit[0] = 1;
	/*for(i = 1; i <=n; i++)
	{
	dis[i] = map[s][i];
	}*/
	//visit[s] = 1;  //第一个顶点即原点，被访问
	//dis[s] = 0; //s到s 即为0
	for(i = 1; i < n; i++)
	{
		min = INF;
		//找到最小的
		for (j = 1; j <= n; j++)
		{
			if ( !visit[j] && dis[j] < min)
			{
				min = dis[j];
				k = j;   //最小的顶点
			}
		}
		visit[k] = 1; //k顶点被访问
		//这里就是比较：直接到还是转一下再到
	          //答曰：从源点一个一个向外扩展，具有最优子结构。每个dis[i]都保留着从s到i的最短距离。转多下的情况把它分解开，就知道了
		for(j = 1; j <= n; j++)   
		{
			if ( !visit[j] && dis[j] > dis[k] + map[k][j])
			{
				dis[j] = dis[k] + map[k][j];
			}
		}
	}

}
int main()
{
	int i,j,n;
	int p,q,t,w;
	int  minx ,ww;
	while ( scanf("%d %d",&n,&m) != EOF)
	{
		if(0 == n&&0 == m) break;
		//memset(dis,0,sizeof(dis));
		memset(map,0x3f,sizeof(map));
		for (i = 1; i<= n; i++)
			for(j = 1; j <= n; j ++)
			{
				map[i][j] = INF;
			}
			for(i = 1; i <= m; i++)
			{
				scanf("%d%d%d",&p,&q,&t);
				map[p][q]=map[q][p]=t;  //注意,因为是把S(目的地)看成源点，所以有向图方向要反过来啊
			}
			dijkstra(1,n);
			printf("%d\n",dis[n]);
	}
	return 0;
}
/*
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
*/

 

//多起点一个中终点的有向图最短路径hdu2680
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define INF 999999
#define sf scanf
#define pf printf
#define MAXN 1000
#define M 2002    
#define N 1002    //这些看题目数据范围
int m,s;
int map[M][M];    //map[i][j]表示i到j的权值
int dis[N];        //dis[i] 表示原点s到i的距离
int visit[N];      //顶点是否被访问过
void dijkstra(int s,int n)
{
	int i,j,k = 0;
	int min;
	memset(visit,0,sizeof(visit));  //初始时都没被访问过
	for( i = 1; i <= n; i++ )
		dis[i]=map[s][i];
	dis[s] = 0;
	visit[s] = 1;
	/*for(i = 1; i <=n; i++)
	{
	dis[i] = map[s][i];
	}*/
	//visit[s] = 1;  //第一个顶点即原点，被访问
	//dis[s] = 0; //s到s 即为0
	for(i = 1; i < n; i++)
	{
		min = INF;
		//找到最小的
		for (j = 1; j <= n; j++)
		{
			if ( !visit[j] && dis[j] < min)
			{
				min = dis[j];
				k = j;   //最小的顶点
			}
		}
		visit[k] = 1; //k顶点被访问
		//这里就是比较：直接到还是转一下再到
		//答曰：从源点一个一个向外扩展，具有最优子结构。每个dis[i]都保留着从s到i的最短距离。转多下的情况把它分解开，就知道了
		for(j = 1; j <= n; j++)   
		{
			if ( !visit[j] && dis[j] > dis[k] + map[k][j])
			{
				dis[j] = dis[k] + map[k][j];
			}
		}
	}

}
int main()
{
	int i,j,n;
	int p,q,t,w;
	int  minx ,ww;
	while ( scanf("%d %d",&n,&m) != EOF)
	{
		if(0 == n&&0 == m) break;
		//memset(dis,0,sizeof(dis));
		memset(map,0x3f,sizeof(map));
		for (i = 1; i<= n; i++)
			for(j = 1; j <= n; j ++)
			{
				map[i][j] = INF;
			}
			for(i = 1; i <= m; i++)
			{
				scanf("%d%d%d",&p,&q,&t);
				map[p][q]=map[q][p]=t;  //注意,因为是把S(目的地)看成源点，所以有向图方向要反过来啊
			}
			dijkstra(1,n);
			printf("%d\n",dis[n]);
	}
	return 0;
}
/*
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
*/

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define inf 10000000
int map[101][101];
int N,M;
int A,B,C;
void Flody(){
	int i,j,k;
	for(k=1;k<=N;k++)
		for(i=1;i<=N;i++)
			for(j=1;j<=N;j++)
				if(map[i][k]+map[k][j]<map[i][j])
					map[i][j]=map[i][k]+map[k][j];
}
void init(){
	int i,j;
	for(i=1;i<=N;i++)
		for(j=1;j<=N;j++){
			map[i][j]=inf;
			if(i==j)
				map[i][j]=0;
		}
}
void read(){
	int i,j,k;
	for(i=0;i<M;i++){
		cin>>A>>B>>C;
		map[A][B]=map[B][A]=C;
	}
}
int main(){
	int i,j,k;
	while(cin>>N>>M&&N&&M){
		init();
		read();
		Flody();
		cout<<map[1][N]<<endl;
	}
	return 0;
}