最短路径算法(Shortest Paths Algorithm)

/*邻接表 +  Dijkstra求最短路*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<climits>
using namespace std;
const int NV = 102;
const int NE = 20002;
int n, m; 
struct Dijkstra
{    
	int n, size;  
	int dis[NV], head[NV];  
	int mark[NV];   
	struct node
	{     
		int v, dis;   
		node () {}  
		node (int V, int DIS) : v(V), dis(DIS) {}  
		friend bool operator < (const node a, const node b)
		{        
			return a.dis > b.dis;  
		} 
	};   
	struct edge
	{      
		int v, w, next;     
		edge () {}    
		edge (int V, int NEXT, int W = 0) : v(V), next(NEXT), w(W) {} 
	}E[NE];  
	inline void init(int x) 
	{     
		n = x, size = 0;    
		memset(head, -1, sizeof(int) * (x + 1));  
	}   
	inline void insert(int u, int v, int w) 
	{      
		E[size] = edge(v, head[u], w);   
		head[u] = size++;  
	}     
	void print() 
	{     
		for (int i = 0; i < n; i++)
		{        
			printf("%d: ", i);     
			for (int j = head[i]; j != -1; j = E[j].next) 
			{          
				printf(" %d", E[j].v);         
			}puts("");    
		}   
	}   
	int dijkstra(int src, int des) 
	{      
		node first, next;   
		priority_queue <node> Q;    
		for (int i = 0; i <= n; i++)
		{       
			dis[i] = INT_MAX;     
			mark[i] = false; 
		}    
		dis[src] = 0;   
		Q.push(node(src, 0));   
		while (!Q.empty())
		{     
			first = Q.top();     
			Q.pop();    
			mark[first.v] = true;   
			for (int i = head[first.v]; i != -1; i = E[i].next) 
			{              
				if (mark[E[i].v]) continue;     
				next = node(E[i].v, first.dis + E[i].w);        
				if (next.dis < dis[next.v]) 
				{             
					dis[next.v] = next.dis;       
					Q.push(next);     
				}       
			}    
		}//while     
		return dis[des];  
	}//Dij
}G; 
int main()
{  
	while (~scanf("%d%d", &n, &m), n || m)
	{      
		G.init(n);    
		while (m--) 
		{        
			int u, v, w;     
			scanf("%d %d %d", &u, &v, &w);    
			G.insert(u - 1, v - 1, w);    
			G.insert(v - 1, u - 1, w);    
		}        //G.print();   
		printf("%d\n", G.dijkstra(0, n - 1)); 
	}   
	return 0;
}

/*邻接表 +  优先队列 + Dijkstra求最短路*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<climits>
#include<queue>
using namespace std;
const int NV = 102;
const int NE = 20002;
int n, m; 
struct Dijkstra 
{   
	int n, size; 
	int dis[NV], head[NV];  
	int mark[NV];  
	struct node 
	{     
		int v, dis;      
		node () {}    
		node (int V, int DIS) : v(V), dis(DIS) {}     
		friend bool operator < (const node a, const node b) 
		{          
			return a.dis > b.dis;  
		} 
	};  
	struct edge
	{      
		int v, w, next;    
		edge () {}    
		edge (int V, int NEXT, int W = 0) : v(V), next(NEXT), w(W) {}   
	}E[NE]; 
	inline void init(int vx) 
	{   
		n = vx, size = 0;  
		memset(head, -1, sizeof(int) * (vx + 1));  
	}   
	inline void insert(int u, int v, int w)
	{     
		E[size] = edge(v, head[u], w);   
		head[u] = size++; 
	}   
	void print()
	{     
		for (int i = 0; i < n; i++)
		{        
			printf("%d: ", i);  
			for (int j = head[i]; j != -1; j = E[j].next) 
			{              
				printf(" %d", E[j].v);    
			}
			puts("");    
		} 
	}  
	int dijkstra(int src, int des)
	{       
		node first, next;  
		priority_queue <node> Q;   
		for (int i = 0; i <= n; i++)
		{        
			dis[i] = INT_MAX;    
			mark[i] = false;      
		}      
		dis[src] = 0;   
		Q.push(node(src, 0));   
		while (!Q.empty())
		{         
			first = Q.top();     
			Q.pop();    
			mark[first.v] = true;    
			for (int i = head[first.v]; i != -1; i = E[i].next)
			{          
				if (mark[E[i].v]) continue;     
				next = node(E[i].v, first.dis + E[i].w);        
				if (next.dis < dis[next.v]) 
				{           
					dis[next.v] = next.dis;           
					Q.push(next);         
				}        
			}      
		}//while     
		return dis[des];  
	}//Dij
}G; 
int main()
{   
	while (~scanf("%d%d", &n, &m), n || m) 
	{     
		G.init(n);   
		while (m--)
		{      
			int u, v, w;      
			scanf("%d %d %d", &u, &v, &w);    
			G.insert(u - 1, v - 1, w);      
			G.insert(v - 1, u - 1, w);    
		}        //G.print();     
		printf("%d\n", G.dijkstra(0, n - 1));   
	}  
	return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<climits>
#include<queue>
#include<stack>
using namespace std;
const int NV = 101;
const int NE = 20001;
const int inf = INT_MAX >> 1;
struct SPFA 
{   
	int n, size; 
	int dis[NV], head[NV]; 
	bool in[NV];   
	struct edge 
	{       
		int v, w, next;  
		edge () {}  
		edge (int V, int NEXT, int W = 0) : v(V), next(NEXT), w(W) {} 
	}E[NE];  
	void init(int nn)
	{     
		n = nn, size = 0;    
		for (int i = 0; i <= n; i++)
		{       
			head[i] = -1;     
			in[i] = 0;         
			dis[i] = inf;  
		}   
	}   
	inline void insert(int u, int v, int w)
	{     
		E[size] = edge(v, head[u], w);     
		head[u] = size++;   
	}    
	inline bool relax(int u, int v, int w)
	{      
		if (dis[v] == inf || dis[u] + w < dis[v]) 
		{       
			dis[v] = dis[u] + w;      
			return true;     
		}      
		return false;  
	}    
	int spfa(int src, int des) 
	{    
		queue<int> que;     
		dis[src] = 0;   
		que.push(src);    
		in[src] = true;     
		while (!que.empty()) 
		{        
			int u = que.front();    
			que.pop();        
			in[u] = false;        
			for (int i = head[u]; i != -1; i = E[i].next)
			{            
				int v = E[i].v;            
				if (relax(u, v, E[i].w) && !in[v] ) 
				{            
					in[v] = true;        
					que.push(v);    
				}//if    
			}//for      
		}//while       
		return dis[des];   
	}//SFPA
}G; 
	
int main()	
{ 	
	int n, m;    
	while (~scanf("%d%d", &n, &m), n | m)
	{      
		G.init(n);     
		int a, b, c;    
		for (int i = 0; i < m; i++) 
		{         
			scanf("%d%d%d", &a, &b, &c); 
			G.insert(a, b, c);       
			G.insert(b, a, c);     
		}       
		printf("%d\n", G.spfa(1, n)); 
	}    
	return 0;	
}