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;
}