Hdu-2544 最短路（Bellman_Ford/Dijkstra/SPFA/Floyd）

//Bellman-Ford算法
//描述:思想为连续对每条边进行松弛操作，在每次松弛时把每条边都更新一下，若在V-1次松弛后还能更新，
//则说明图中有负环。可以求含负权图及判定负环的最短路算法。 
//复杂度: O(VE)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=110;
const int Max_m=2e4+10;
const int inf=0x3f3f3f3f;

int n,m;
struct edge{
	int from,to,cost;
}e[Max_m];

int d[Max_n];

int Bellman_Ford(int s,int t){
	memset(d,0x3f,sizeof(d));
	d[s]=0;
	//int k=0;
	while(true){
		bool flag=false;
		for(int i=0;i<2*m;i++){
			if(d[e[i].from]+e[i].cost<d[e[i].to]){
				d[e[i].to]=d[e[i].from]+e[i].cost;
				flag=true;
			}
		}
		if(!flag)break;
		//if(n=++k){printf("存在负环\n");return; }
	}
	return d[t];
}

int main()
{
	while(~scanf("%d%d",&n,&m)&&n+m){
		int a,b,c;
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&a,&b,&c);
			e[i*2].from=a;e[i*2].to=b;e[i*2].cost=c;
			e[i*2+1].from=b;e[i*2+1].to=a;e[i*2+1].cost=c;
		}
		printf("%d\n",Bellman_Ford(1,n));
	}
	return 0;
}

//Dijkstra算法
//描述:思想为运用贪心策略（没有负边），不断从已经确定最短距离的顶点集合（开始只有起点s）
//向外找与该顶点集合距离最近的顶点，加入到该集合并更新与该顶点相连顶点的最短距离。 
//复杂度: 邻接表+优先队列 O(ElogV) 

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue> 
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> P;
const int Max_n=110;
const int Max_m=2e4+10;
const int inf=0x3f3f3f3f;

int n,m;
struct edge{
	int to,cost;
	edge(int t,int c):to(t),cost(c){}
};
int d[Max_n];
vector<edge>G[Max_n];
priority_queue<P,vector<P>,greater<P> >que;

int Dijkstra(int s,int t){
	memset(d,0x3f,sizeof(d));
	que.push(P(0,s));
	d[s]=0;
	
	while(!que.empty()){
		P p=que.top();que.pop();
		int v=p.second;
		if(p.first>d[v])continue; 
		for(int i=0;i<G[v].size();i++){
			edge e=G[v][i];
			if(d[v]+e.cost<d[e.to]){
				d[e.to]=d[v]+e.cost;
				que.push(P(d[e.to],e.to));
			}
		}
	}
	return d[t];
}


int main()
{
	while(~scanf("%d%d",&n,&m)&&n+m){
		for(int i=0;i<=n;i++)G[i].clear(); //Vector容器清空!
		int a,b,c;
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&a,&b,&c);
			G[a].push_back(edge(b,c));
			G[b].push_back(edge(a,c));
		}
		printf("%d\n",Dijkstra(1,n));
	}
	return 0;
}

//SPFA算法
//描述: 队列优化后的Bellman-Ford算法，减少了冗余的松弛操作。
//优化：在Bellman-Ford算法中，要是某个点的最短路径估计值更新了，那么我们必须对所有边指向的终点再做一次松弛操作；
//在SPFA算法中，某个点的最短路径估计值更新，只有以该点为起点的边指向的终点需要再做一次松弛操作。 
//复杂度: O(kE) 

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue> 
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> P;
const int Max_n=110;
const int Max_m=2e4+10;
const int inf=0x3f3f3f3f;

int n,m;
struct edge{
	int to,cost;
	edge(int t,int c):to(t),cost(c){}
};
int d[Max_n];
vector<edge>G[Max_n];
int cnt[Max_n];
bool vis[Max_n];
queue<int>que;

int SPFA(int s,int t){
	memset(d,0x3f,sizeof(d));
	memset(cnt,0,sizeof(cnt));
	memset(vis,0,sizeof(vis));
	que.push(s);
	vis[s]=1;cnt[s]=1;d[s]=0;
	while(!que.empty()){
		int v=que.front();que.pop();
		vis[v]=0;
		for(int i=0;i<G[v].size();i++){
			edge e=G[v][i];
			if(d[v]+e.cost<d[e.to]){
				d[e.to]=d[v]+e.cost;
				if(!vis[e.to]){
					que.push(e.to);
					vis[e.to]=1;
					if(++cnt[e.to]>n)return -1; // 判定负环 
				}
			}
		}
	}
	return d[t];
}

int main()
{
	while(~scanf("%d%d",&n,&m)&&n+m){
		for(int i=0;i<=n;i++)G[i].clear(); //Vector容器清空!
		int a,b,c;
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&a,&b,&c);
			G[a].push_back(edge(b,c));
			G[b].push_back(edge(a,c));
		}
		printf("%d\n",SPFA(1,n));
	}
	return 0;
}

//Floyd算法
//描述: 运用动态规划思想的一个经典多源最短路算法。
//可以处理负权图的最短路和传递闭包，而判断图中是否有负圈，只需要检查是否存在d[i][i]是负数的顶点i就可以了。
//递推方程：d[i][j]=min(d[i][j],d[i][k]+d[k][j])
//复杂度: O(v3)

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue> 
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> P;
const int Max_n=110;
const int Max_m=2e4+10;
const int inf=0x3f3f3f3f;

int n,m;
int path[Max_n][Max_n];
int d[Max_n][Max_n];

void init(){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			d[i][j]=inf;
			path[i][j]=j;
			if(i==j)d[i][j]=0; //path[i][j]=x表示i到j的路径上(除i外)的第一个点是x
		}
	}
}

void Floyd(){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(d[i][j]>d[i][k]+d[k][j]){
					d[i][j]=d[i][k]+d[k][j];
					path[i][j]=path[i][k];
				}
			}
		}
	}
}

void getpath(int st,int ed){ //打印路径
    while(st!=ed) {
        printf("%d->",st);
        st=path[st][ed];
    }
    printf("%d\n",ed);
}

int main()
{
	while(~scanf("%d%d",&n,&m)&&n+m){
		for(int i=0;i<=n;i++){
			
		}
		init();
		int a,b,c;
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&a,&b,&c);
			d[a][b]=c;
			d[b][a]=c;
		}
		Floyd();
		printf("%d\n",d[1][n]);
		//getpath(1,n);
	}
	return 0;
}