SDNUOJ 1224.Tom‘problem B(Dijkstra算法/Floyd算法/Bellman-Ford算法)

Time Limit: 1000 MS Memory Limit: 131072 KB

Description
Tom is a student in Shan Dong Normal University! his University in the suburbs,this day,Tom wanted to go to the downtown to visit his old friend Jerry,But tom faced a problem ,he want to know how to reach the city center fastest,now the bus stations of city are n[2,100], there are m[1,1000] bus routes in the city
Tom in the 1st bus station,Jerry in the Nth bus station

Input
The fist line is m,n;
Next m lines is a,b,c (a,b is the name of bus station , c is the time you cost from station a to station b)

Output
The shortest time tom reach city center

Sample Input
1 2
1 2 10
3 4
1 2 10
2 3 10
3 4 10

Sample Output
10
30

Floyd算法实现：

#include<iostream>
using namespace std;
int dat[105][105];//邻接矩阵存放图，数组的大小也要根据题目要求进行改变
int main()
{	
int m,n,a,b,c,maxn=99999999;//maxn是自己定义的一个最大值，看具体情况进行修改
	while(cin>>m>>n)//n是节点的个数，m是路线的个数
	{
		for(int i=1;i<=n;++i)//初始化图，自己到自己的距离是零，自己和到不了的地点之间的距离是无穷
		{
			for(int j=1;j<=n;++j)
			{
				if(i==j) dat[i][j]=0;
				else
				dat[i][j]=maxn;
			}
		}
		for(int i=1;i<=m;++i)
		{
			cin>>a>>b>>c;
			dat[a][b]=c;//指a到b的距离是c
			dat[b][a]=c;//这里是无向图的存储，若为有向图则只留符合要求的一个
		}
		for(int k=1;k<=n;++k)//下面是Floyd算法的核心
		{
			for(int i=1;i<=n;++i)
			{
				for(int j=1;j<=n;++j)
				{
					if(dat[i][k]+dat[k][j]<dat[i][j])//尝试用别的点作为中转是否可以得到更短的路径
					dat[i][j]=dat[i][k]+dat[k][j];
				}
			}
		}
		cout<<dat[1][n]<<endl;//输出答案，这里输出的是1到n的最短距离
	}
	return 0;
}

Dijkstra算法实现：

#include<iostream>
using namespace std;
const int maxn=105; 
const int inf=99999999;//自己定一个最大值 
int map[maxn][maxn],dis[maxn];//map是图的邻接矩阵，dis是一点到某点的实时最短距离 
bool vis[maxn];//vis代表这个点是否已经确定了到那一点的最小路径 
int main()
{
	int m,n,a,b,c;
	while(cin>>m>>n)
	{
		vis[1]=1;//1到1本身的最短距离就是0，已经确认所以标记为1 
		for(int i=1;i<=n;++i)
		{
			for(int j=1;j<=n;++j)
			{
				if(i==j) map[i][j]=0;
				else map[i][j]=inf;//初始化图的邻接矩阵 
			}
		}
		for(int i=1;i<=m;++i)
		{
			cin>>a>>b>>c;
			if(map[a][b]>c)//判断条件是否合理 
			{ 
				map[a][b]=c;
				map[b][a]=c;//这一题是无向图，如果写成有向图会wa，也很容易想为什么，因为变成有向图后某些路就走不通了。 
			}
		}
		for(int i=1;i<=n;++i)
		{
			dis[i]=map[1][i];//先初始化dis为1到各点的距离 
		}
		for(int i=1;i<=n-1;++i)
		{
			int min=inf,u;
			for(int j=1;j<=n;++j)
			{
				if(!vis[j]&&dis[j]<min)
				{
					min=dis[j];
					u=j;
				}
			}//找出此时还没确定的点到1的最小值 
			vis[u]=1;//先标记该点的最小值已经确定，下面进行操作 
			for(int j=1;j<=n;++j)
			{
				if(map[u][j]<inf)//找到u点能到达的点 
				{
					if(dis[j]>dis[u]+map[u][j])
					dis[j]=dis[u]+map[u][j];//更新u点能到达的点的最小值 
				}
			}
		}
		cout<<dis[n]<<endl;
		for(int i=1;i<=n;++i)
		{
			for(int j=1;j<=n;++j)
			{
				map[i][j]=0;
			}
		}
		for(int i=1;i<=n;++i)
		{
			vis[i]=0;
			dis[i]=0;
		}
	}
	return 0;
} 

Bellman-Ford算法实现：

#include<iostream>
using namespace std;
const int inf=999999999;
struct edge{
	int point1;
	int point2;
	int value;
}dat[1005];
int dis[105];
int main()
{
	int m,n;
	while(cin>>m>>n)
	{
		for(int i=1;i<=n;++i)
		{
			dis[i]=inf;
		}
		dis[1]=0;
		for(int i=1;i<=m;++i)
		{
			cin>>dat[i].point1>>dat[i].point2>>dat[i].value;
		}
		for(int i=m+1;i<=m*2;++i)
		{
			dat[i].point1=dat[i-m].point2;
			dat[i].point2=dat[i-m].point1;
			dat[i].value=dat[i-m].value;
		}//因为是无向图所以进行这个操作
		for(int i=1;i<n;++i)//Bellman-Ford算法的核心，就是对所有边松弛最多n-1次，这是未经任何优化的代码 
		{
			for(int j=1;j<=m*2;++j)
			{
				//cout<<dat[j].point1<<"->"<<dat[j].point2<<" "<<dat[j].value<<endl;
				if(dis[dat[j].point2]>dis[dat[j].point1]+dat[j].value)
					dis[dat[j].point2]=dis[dat[j].point1]+dat[j].value;
			}
		}
		cout<<dis[n]<<endl;
	}
	return 0;
}