【王道】Floyd算法/Dijkstra算法求最短路径0x3f3f3f3f

 【最短路径之Floyd】

1.Floyd算法适合全源最短路问题，它要求被解图的大小不大于200个结点；

2.当图使用邻接矩阵表示时更为方便

3.注意当两个结点间有多余一条边时，选择长度最小的边权值存入邻接矩阵

#include<iostream>
#include<cstring>
#include<vector>
#include<math.h>
#include<algorithm>
using namespace std;
int ans[101][101];
int main(int argc, char const *argv[])
{
	int N,m,a,b,c;
	while(cin>>N)
	{
		cin>>m;
		if(m==N&&m==0)break;
		memset(ans,0,sizeof(ans));
		while(m--)
		{
			cin>>a>>b>>c;
			ans[b][a]=ans[a][b]=c;
		}
		for(int k=1;k<=N;k++)
		{
			for(int i=1;i<=N;i++)
			{
				for (int j=1;j<=N;++j)
				{
					if(ans[i][j]>ans[i][k]+ans[k][j])
						ans[i][j]=ans[i][k]+ans[k][j];
				}
			}
		}
		cout<<ans[1][N]<<endl;
	}
	return 0;
}

【 最短路径之Dijkstra】

1.适合单源最短路径问题，只能求得某特定点到其他所有结点的最短路径长度

2.当确定一个结点的最短路径长度时，该最短路径上所有中间结点的最短路径长度必然已经被确定了

3.最好使用邻接链表来实现

#include<iostream>
#include<cstring>
#include<vector>
#include<math.h>
#include<algorithm>
using namespace std;
#define maxi 0x3f3f3f3f
struct edge
{
	int b,c;
};
std::vector<edge> v[100];
bool mark[100];
int dis[100];
int n,m;
void dijkstra(int s)
{
	dis[s]=0;
	mark[s]=true;
	int newp=s,mindis=maxi;
	int next,cost;
	for(int i=1;i<n;i++)//确保循n-1次
	{
		for(int j=0;j<v[newp].size();j++)
		{
			next=v[newp][j].b;
			cost=v[newp][j].c;
			if(mark[next])continue;
			if(dis[next]>dis[newp]+cost)
				dis[next]=dis[newp]+cost;
		}
		for(int k=1;k<=n;k++)
		{
			if(mark[k])continue;
			if(mindis>dis[k])
			{
				mindis=dis[k];
				newp=k;
			}

		}
		mark[newp]=true;
	}

}
int main(int argc, char const *argv[])
{
	int a,b,c;
	while(cin>>n)
	{
		cin>>m;
		if(n==m&&n==0)break;
		for(int i=0;i<100;i++)v[i].clear();
		memset(mark,false,sizeof(mark));
	    fill(dis,dis+100,maxi);
		while(m--)
		{
			cin>>a>>b>>c;
			edge temp;
			temp.b=b;
			temp.c=c;
			v[a].push_back(temp);
			temp.b=a;
			v[b].push_back(temp);
		}
		dijkstra(1);
		cout<<dis[n]<<endl;
	}
	return 0;
}