HDU2544:最短路(Dijkstra,SPFA)

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<cstring>
#include<queue>
#include<algorithm>
#include<vector>
#include<functional>

using namespace std;
typedef pair<int,int> pr;
const int maxn = 1000;
vector<int>g[maxn];
struct edge {
	int u, v, w;
};
vector<edge>edges;
int n, m, book[maxn], dis[maxn];
void insert(int x, int y, int z)
{
	edges.push_back(edge{ x,y,z });
	g[x].push_back(edges.size() - 1);
}
void dijkstra()
{
	memset(book, 0, sizeof(book));
	memset(dis, 0x3f, sizeof(dis));

	dis[1] = 0;
	priority_queue<pr, vector<pr>, greater<pr> >q;
	q.push(make_pair(0, 1));
	while (!q.empty())
	{
		pr tmp = q.top(); q.pop();
		int x = tmp.second; int d = tmp.first;
		if (book[x])continue; book[x] = 1;

		for (int i = 0; i < g[x].size(); i++)
		{
			edge e = edges[g[x][i]];
			if (dis[e.v] > dis[x] + e.w) {
				dis[e.v] = dis[x] + e.w;
				q.push(make_pair(dis[e.v], e.v));
			}
		}
	}
}
int main()
{
	while (cin >> n >> m)
	{
		if (!n)break;
		edges.clear(); for (int i = 0; i <= n; i++)g[i].clear();
		for (int i = 1; i <= m; i++)
		{
			int x, y, z; cin >> x >> y >> z;
			insert(x, y, z); insert(y, x, z);
		}
		dijkstra();
		cout << dis[n] << endl;
	}

	return 0;
}
   
   

   
   

  
  
  
  

   
   

  
  

#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;

int n,m,map[510][510],book[510],dis[510];
vector<int>g[510];
struct node{
	int x,d;
	friend bool operator <(node n1,node n2)
	{
		return n1.d>n2.d;
	}
};
const int inf=0x3f3f3f3f;
void dijkstra()
{
	memset(book,0,sizeof(book));
	memset(dis,0x3f,sizeof(dis));
	
	dis[1]=0;
	priority_queue<node>q;
	q.push(node{1,0});
	
	while(!q.empty())
	{
		node tmp=q.top();q.pop();
		int x=tmp.x;if(book[x])continue;
		book[x]=1;
		
		for(int i=0;i<g[x].size();i++)
		{
			if(dis[g[x][i]]>dis[x]+map[x][g[x][i]])
			{
				dis[g[x][i]]=dis[x]+map[x][g[x][i]];
				q.push(node{g[x][i],dis[g[x][i]]});
			}		
		}
		
	 } 
	
}
int main()
{
	while(cin>>n>>m,n+m)
	{
		for(int i=0;i<=n;i++)g[i].clear();
		
		for(int i=1;i<=m;i++)
		{
			int x,y,z;cin>>x>>y>>z;
			map[x][y]=map[y][x]=z;
			g[x].push_back(y);g[y].push_back(x);
		}
		dijkstra();
		cout<<dis[n]<<endl;
	}
	return 0;
}
法二：队列优化的Bellman-Ford

SPFA

#include<iostream>
#include<vector>
#include<queue>
#include<cstring> 
using namespace std;

const int inf=0x3f3f3f3f;
vector<int>g[201]; 
int map[200][200];
int n,m;
int dis[200],book[210];
int cnt[210];
bool spfa()
{
	memset(dis,0x3f,sizeof(dis));
	memset(book,0,sizeof(dis));
	dis[1]=0;
	book[1]=1;
	queue<int>q;q.push(1);
	while(!q.empty())
	{
		int x=q.front();q.pop();
		book[x]=0;
		
		for(int i=0;i<g[x].size();i++)
		{
			int nx=g[x][i];
	
			if(dis[nx]>dis[x]+map[x][nx])
			{
				dis[nx]=dis[x]+map[x][nx];
				if(!book[nx])
				{
					book[nx]=1;
					q.push(nx);
				//	if(++cnt[nx]==n){cout<<"有负环"<<endl;return false; }
				}
			}
			
		}
	}
	return true;
}
int main()
{
	while(cin>>n>>m,n+m)
	{
		for(int i=0;i<=n;i++)g[i].clear();
		memset(cnt,0,sizeof(cnt)); 
		for(int i=1;i<=m;i++)
		{
			int x,y,z; cin>>x>>y>>z;
			g[x].push_back(y);g[y].push_back(x);
			map[x][y]=map[y][x]=z;
		}	
		spfa();
		cout<<dis[n]<<endl;
	} 
	return 0;
}