最短路径算法Dijkstra && SPFA && Floyd 代码实现模板

    本文建立在已经了解这三种算法基本思想的基础上，不再对算法进行详细的描述，而是对思想进行比较优秀的代码实现的总结，可以直接用于ACM题目或者实际问题的解决中。

Dijkstra算法：

    Dijkstra算法是指定一个源点，求得这个源点到各个点的最短路径。Dijkstra算法通过不断的松弛边，并且进行记录，每次更新相邻点的路径，采用类似贪心的思想，使两点之间的距离成为最短的路径。

    Dijkstra算法缺点是不能有负权边的值。

#define INF 0x3f3f3f3
const int MAX_N=200;
int map[MAX_N][MAX_N],vis[MAX_N],dis[MAX_N];//dis代表到每个点的最短距离 
//注意先把map[][]=INF 
void dijkstr(int x,int m){//x代表开始点，m代表顶点个数 
	for(int i=1;i<=m;i++){
		dis[i]=map[x][i];
		vis[i]=0;
      // if(map[x][i]!=INF)
		//pre[i]=x;
		//else
		//pre[i]=-1;
	}
	int p;
	vis[x]=1;
	for(int i=1;i<=m;i++){
	   	int min=INF;
	   	for(int j=1;j<=m;j++){
	   		if(!vis[j]&&dis[j]<min){
		   		min=dis[j];
		   		p=j;
		   	}   	
	   	}
	   	vis[p]=1;
		for(int j=1;j<=m;j++){
			if(!vis[j]&&dis[p]+map[p][j]<dis[j])
			{
              dis[j]=dis[p]+map[p][j];
               //pre[j]=p;
           }
		}	   	
	}
}


int main(){
	int m,n,a,b,c;
	void dijkstr(int x,int n);
	while(cin>>m>>n&&(m||n)){
		memset(vis,0,sizeof(vis));
		for(int i=1;i<=m;i++)
		for(int j=1;j<=m;j++){
			 map[i][j]=INF;
		}
		for(int j=1;j<=n;j++){
			cin>>a>>b>>c;
			map[a][b]=map[b][a]=c;
		}
		dijkstr(1,m);
		cout<<dis[m]<<endl;
      /* int p,len=1;
		p=m;
		while(p>=1)
	    {
           ans[len++]=p;
           p=pre[p];
		}
	   for(int r=len-1;r>=1;r--)
	   cout<<ans[r];*/
	
	}
	return 0;
}

Floyd算法：

    floyd算法是一个经典的动态规划算法，可以求得任意两点之间的最短路，但是复杂度是O（N3），复杂度较高，不适宜大量点之间最短路的计算。

//floyd算法传递闭包，f数组不能另开，就一定维持这一个 
void Floyd()
{
	for(int k = 1; k <= N; k++)	// 最外层必须是k
	{
		for(int i = 1; i <= N; i++)	
		{
			for(int j = 1; j <= N; j++)
			{
				f[i][j] = f[i][j] || (f[i][k] && f[k][j]);	// 判断连通性 
			}
		}
	}
}
//floyd算法求最短路
void Floyd()
{
	for(int k = 1; k <= N; k++)	// 最外层必须是k
	{
		for(int i = 1; i <= N; i++)	
		{
			for(int j = 1; j <= N; j++)
			{
				if(f[i][j]>f[i][k]+f[k][j])
				f[i][j]=f[i][k]+f[k][j];
			}
		}
	}
}

SPFA算法：

    单源最短路径中如果有负权边的存在，这个时候就不能使用Dijkstra算法了。SPFA是对Bellman_Ford算法的优化，使用一个先进先出的队列用来保存待优化的结点。

/*
* 单源最短路SPFA
* 时间复杂度 0(kE)
* 这个是队列实现，有时候改成栈实现会更加快，很容易修改
* 这个复杂度是不定的
*/
const int MAXN=1010;
const int INF=0x3f3f3f3f;
struct Edge
{
   int v;
   int cost;
   Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
vector<Edge>E[MAXN];
void addedge(int u,int v,int w)
{
   E[u].push_back(Edge(v,w));
}
bool vis[MAXN];//在队列标志
int cnt[MAXN];//每个点的入队列次数
int dist[MAXN];
bool SPFA(int start,int n)
{
   memset(vis,false,sizeof(vis));
   for(int i=1;i<=n;i++)
   dist[i]=INF;
   vis[start]=true;
   dist[start]=0;
   queue<int>que;
   while(!que.empty())
   que.pop();
   que.push(start);
   memset(cnt,0,sizeof(cnt));
   cnt[start]=1;
   while(!que.empty())
   {
      int u=que.front();
      que.pop();
      vis[u]=false;
      for(int i=0;i<E[u].size();i++)
      {
         int v=E[u][i].v;
         if(dist[v]>dist[u]+E[u][i].cost)
         {
            dist[v]=dist[u]+E[u][i].cost;
            if(!vis[v])
            {
               vis[v]=true;
               que.push(v);
               if(++cnt[v]>n)
			   return false;
               //cnt[i]为入队列次数，用来判定是否存在负环回路
            }
         }
      }
    }
   return true;
}