HDU 2544 最短路(四种写法：Floyd、Dijkstra、Bellman-Ford、SPFA)

Description

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。

输入保证至少存在1条商店到赛场的路线。

Output

对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input

2 1

1 2 3

3 3

1 2 5

2 3 5

3 1 2

0 0

Sample Output

3

2

图论的题目，给出点和边的个数以及每条边两端的点以及权。

Floyd:

#include "iostream"
#include "cstdio"

using namespace std;
int map[105][105];
#define CANTREACH 9999999

int main()
{
int m,n;

while(scanf("%d %d",&n,&m)!=EOF)
{
if(n==0&&m==0)
break;
int x,y,l;
for(int n=1;n<=104;n++)
{
for(int m=1;m<=104;m++)
{
map

=0;
map
[m]=CANTREACH;

}

}

for(int i=1;i<=m;i++)
{
cin>>x>>y>>l;
map[x][y]=map[y][x]=l;
}
int i,j,k;

//floyd
//第一层循环可以看作是从前往后按顺序挑一个点
//挑完之后 计算从起点到这个点的距离 下面两个循环将图中所有的点循环一遍
for(k=1;k<=n;k++)
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
//比较i直接到j短 还是i经过k到j短 存下最短的
map[i][j]=map[i][j]<=map[i][k]+map[k][j] ? map[i][j]:map[i][k]+map[k][j];
}
cout<<map[1]
<<endl;
}
}

Dijkstra:

#include "iostream"
#include "cstdio"

using namespace std;
int map[105][105];
bool visit[105];
int s[105];
int m,n;
#define CANTREACH 9999999

void dji()
{
int next;
for(int i=1;i<=n;i++) //一次求出所有点到起点的最短距离
{

int min=CANTREACH;
for(int j=1;j<=n;j++) //找到没有访问过的 且到起点最近的点
{
if(!visit[j]&&s[j]<=min)
min=s[next=j];//记录坐标
}
visit[next]=true;
if(min==CANTREACH)
break;
for(int j=1;j<=n;j++) //将图上所有的点都刷一遍 比较以刚才找到的点为中转点到j近 还是直接到j近
{
if(s[next]+map[next][j]<=s[j])
s[j]=s[next]+map[next][j];//更新
}
}
}

int main()
{

while(scanf("%d %d",&n,&m)!=EOF)
{
if(n==0&&m==0)
break;
int x,y,l;
for(int n=1;n<=104;n++) //初始化
{
for(int m=1;m<=104;m++)
{
map

=0;
map
[m]=CANTREACH;

}

}

for(int i=1;i<=m;i++)
{
cin>>x>>y>>l;
map[x][y]=map[y][x]=l;
}
memset(visit,false,sizeof(visit));
memset(s,CANTREACH,sizeof(s));
s[1]=0;

dji();

cout<<s
<<endl;

}
}

Bellman-Ford

#include "iostream"
#include "cstdio"
#define INF 9999999
using namespace std;

int m,n;

struct edge
{
int start,end,weight;
} e[10005];

int dis[105];

void BellmanFord()
{
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if(dis[e[j].start]>dis[e[j].end]+e[j].weight)
dis[e[j].start]=dis[e[j].end]+e[j].weight;
if(dis[e[j].end]>dis[e[j].start]+e[j].weight)
dis[e[j].end]=dis[e[j].start]+e[j].weight;

}
}

int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
if(m==0&&n==0) return 0;

memset(dis,INF,sizeof(dis));
for(int i=1;i<=m;i++)
{
int u,v,w;
cin>>u>>v>>w;
e[i].start=u;
e[i].end=v;
e[i].weight=w;

}
dis[1]=0;
BellmanFord();
cout<<dis
<<endl;
}
}

SPFA大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，如果该点没有在队列中，则将其入队。 直到队列为空时算法结束。

#include "cstring"
#include "cstdio"
#include "string.h"
#include "iostream"
#include "queue"
using namespace std;
int head[20005];
long long dis[20005];
int len=0;
int n,m,s;
bool mark[20005];
struct edge
{
int to,next,u,v;
long long weight;
}edge[20005];
void addEdge(int u,int v,long long w)
{
edge[len].u=u;
edge[len].v=v;
edge[len].to=v;
edge[len].next=head[u];
edge[len].weight=w;
head[u]=len;
len++;
}
void spfa()
{
queue <int> list;
list.push(s);
bool vis[1005];
memset(vis,0,sizeof(vis));
memset(dis,0x3f3f3f3f,sizeof(dis));
dis[s]=0;
vis[s]=1;
while(!list.empty())
{
int now=list.front();
list.pop();
vis[now]=0;
for(int i=head[now];i!=-1;i=edge[i].next)
{
int to=edge[i].to;
long long w=edge[i].weight;
if(dis[now]+w<dis[to])
{
dis[to]=dis[now]+w;
if(vis[to]==0)
{
vis[to]=1;
list.push(to);
}
}
}
}
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
if(n+m==0)
break;
memset(head,-1,sizeof(head));
memset(mark,0,sizeof(mark));
len=0;
s=1;
for(int i=0;i<m;i++)
{
int u,v;
long long w;
scanf("%d%d%lld",&u,&v,&w);
addEdge(u, v, w);
addEdge(v, u, w);
}
spfa();
printf("%lld\n",dis
);
}
}