hdu1874(最短路：一道题学习Floyd,Dijkstra,Bellman-Ford,SPFA)

Floyd,Dijkstra,Bellman-Ford,SPFA的比较

/article/7665028.html

Floyd(动态规划)

1，从任意一条单边路径开始。所有两点之间的距离是边的权，

如果两点之间没有边相连，则权为无穷大。

2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短，

如果是更新它。

#include <cstdio>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>

#define MAXN 1005
#define MAX 205
#define INF 0xfffffff

using namespace std;

//struct Path{int u,v,w;}path[MAXN];
int mp[MAX][MAX];
int s,e,n,m;
int u,v,w;
int main(){
while(scanf("%d%d",&n,&m)!=EOF){
//Floyd算法
for(int i=0;i<n;i++) for(int j=0;j<n;j++) if(i!=j)mp[i][j]=INF;
for(int i=0;i<m;i++){
scanf("%d%d%d",&u,&v,&w);
if(mp[u][v]>w) mp[u][v]=mp[v][u]=w;
}
scanf("%d%d",&s,&e);
for(int k=0;k<n;k++)
for(int i=0;i<n;i++)
for(int j=0;j<n;j++){
int t=mp[i][k]+mp[k][j];
if(mp[i][j]>t) mp[i][j]=t;
}
if(mp[s][e]<INF) printf("%d\n",mp[s][e]);
else printf("-1\n");
}//while
return 0;
}

Dijkstra(贪心)

1，初始时令 起点s加入集合A，其余顶点组成集合B，

B中顶点对应的距离值若存在<s,bi>，dis(bi)>为其权值，若不存在dis(bi)为∞

2.，从B中选取一个与A中顶点有关联边且权值最小的顶点t，加入到S中

3.，对其余A中顶点的距离值进行修改：若加进t作中间顶点，从as到ai的距离值缩短，

则修改此距离值重复上述步骤2、3，直到A中包含所有顶点

#include <cstdio>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <queue>

#define MAXN 1005
#define MAX 205
#define INF 0xfffffff

using namespace std;

//struct Path{int u,v,w;}path[MAXN];
int mp[MAX][MAX];
int s,e,n,m;
int u,v,w;
int dis[MAX],vis[MAX];
void Dijkstra(){
int i,j,k,mi;
memset(vis,0,sizeof(vis));
for(i=0;i<n;i++) dis[i]=mp[s][i];
dis[s]=0;
for(i=0;i<n;i++){
mi=INF;
for(j=0;j<n;j++){
if(!vis[j]&&dis[j]<mi){
mi=dis[j];
k=j;
}//if
}//for_j
if(mi==INF) break;
vis[k]=1;
for(j=0;j<n;j++)
if(!vis[j]&&dis[j]>dis[k]+mp[k][j])
dis[j]=dis[k]+mp[k][j];
}
if(dis[e]<INF) printf("%d\n",dis[e]);
else printf("-1\n");
}

int main(){
while(scanf("%d%d",&n,&m)!=EOF){
for(int i=0;i<n;i++) for(int j=0;j<n;j++) mp[i][j]=INF;
for(int i=0;i<m;i++){
scanf("%d%d%d",&u,&v,&w);
if(mp[u][v]>w) mp[u][v]=mp[v][u]=w;
}
scanf("%d%d",&s,&e);
Dijkstra();

}//while
return 0;
}

Bellman-Ford

1，初始化：将除源点外的所有顶点的最短距离值 d[i]置为∞, d[s]=0;

2，迭代求解：对每条边 ，dist[Vi] + (Vi,Vj)和dist[Vj],并将小的赋给dist[Vj]

（重复以上操作n − 1次）

3，检验负权回路（本题略）再重复操作一次，如dist[Vj] > dist[Vi] + (Vi,Vj),则此图存在负权环

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>
#include <vector>
#include <queue>

#define MEM(a,x) memset(a,x,sizeof a)
#define eps 1e-8
#define MOD 10009
#define MAXN 205
#define MAXM 2005
#define INF 99999999
#define ll __int64
#define bug cout<<"here"<<endl
#define fread freopen("ceshi.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)

using namespace std;

int n,m,s,e;
struct Path{
int  u,v,w;
}p[MAXM];
int dis[MAXN];

void Bellman_Ford(){
int i,j;
for(i=0;i<n;i++)  dis[i] = INF;
dis[s]=0;
for(i=0;i<n;i++)
for(j=0;j<2*m;j++)
dis[p[j].u]=min(dis[p[j].u],dis[p[j].v]+p[j].w);
if(dis[e]<INF) printf("%d\n",dis[e]);
else printf("-1\n");
}
int main(){
int u,v,w;
int i,j;
while(scanf("%d%d",&n,&m)!=EOF){
s=1;e=n;
int num=0;
//for(i=0;i<=n;i++) for(j=0;j<=n;j++) mp[i][j]=INF;
for(i=0;i<m;i++){
scanf("%d%d%d",&u,&v,&w);
p[num].u=u;
p[num].v=v;
p[num++].w=w;
p[num].u=v;
p[num].v=u;
p[num++].w=w;
}
scanf("%d%d",&s,&e);
Bellman_Ford();
}
return 0;
}

SPFA---------bfs方法

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <set>
using namespace std;

#define INF 999999999
int mp[210][210],flag[210],d[210];
int m,n,s,e;
void SPFA(){
int i,x;
queue<int>q;
memset(flag,0,sizeof(flag));
for(i=0;i<n;i++) d[i]=INF;
d[s]=0;
q.push(s);
while(!q.empty()){
x=q.front();
q.pop();
flag[x]=0;
for(i=0;i<n;i++){
if(d[i]>d[x]+mp[x][i]){
d[i]=d[x]+mp[x][i];
if(!flag[i]){q.push(i);flag[i]=1;}
}//if
}//for
}//while
printf("%d\n",d[e]<INF?d[e]:-1);
}
int main(){
int i,j,a,b,c;
while(scanf("%d%d",&n,&m)!=EOF){
for(i=0;i<n;i++)for(j=0;j<n;j++)mp[i][j]=INF;
for(i=0;i<m;i++){
scanf("%d%d%d",&a,&b,&c);
if(mp[a][b]>c) mp[a][b]=mp[b][a]=c;
}
scanf("%d%d",&s,&e);
SPFA();
}
return 0;
}