思路:这道题是基础的最短路径算法,可以拿来试一下自己对3种方法的理解
dijkstra主要是从第一个点开始枚举,每次枚举出当当前最小的路径,然后再以那最小的路径点为起点,求出它到其它未标记点的最短距离
bellman-ford 算法则是假设有向网中有n 个顶点、且不存在负权值回路,从顶点v1 和到顶点v2 如果存在最短路径,则此路径最多有n-1 条边。这是因为如果路径上的边数超过了n-1 条时,必然会重复经过一个顶点,形成回路;而如果这个回路的权值总和为非负时,完全可以去掉这个回路,使得v1到v2的最短路径长度缩短。
下面将以此为依据,计算从源点v0 到其他每个顶点u 的最短路径长度dist [u]。
Bellman-Ford 算法构造一个最短路径长度数组序列:dist 1 [u],dist 2 [u],dist 3 [u],…,distn-1 [u]。
其中:
dist 1 [u]为从源点v0 到终点u 的只经过一条边的最短路径长度,并有dist 1 [u] = Edge[v0][u];
dist 2 [u]为从源点v0 出发最多经过不构成负权值回路的两条边到达终点u 的最短路径长度;
dist 3 [u]为从源点v0 出发最多经过不构成负权值回路的三条边到达终点u 的最短路径长度;
……
dist n-1 [u]为从源点v0 出发最多经过不构成负权值回路的n-1 条边到达终点u 的最短路径长
度;
dijkstraAC代码:
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define INF 0x3f3f3f3;
int map[110][110],dis[110],visited[110];
void Dijkstra(int n,int x)
{
int i,p,j,min;
for (i=1;i<=n;i++)
{
dis[i]=map[1][i];
visited[i]=0;
}
visited[x]=1;//顶点v0 加入到顶点集合S
for (i=1;i<=n;i++)//从顶点v1 确定n 条最短路径
{
min=INF;
for (j=1;j<=n;j++)//选择当前集合T 中具有最短路径的顶点p
{
if(!visited[j] && dis[j]<min)
{
p=j;
min=dis[j];
}
}
visited[p]=1;//将顶点p加入到集合S,表示它的最短路径已求得
for (j=1;j<=n;j++)//修改T 集合中顶点的dist值
{
if(!visited[j] && dis[p]+map[p][j]<dis[j])
{
dis[j]=dis[p]+map[p][j];
}
}
}
}
int main()
{
int n,m,i,j,a,b,t;
while(scanf("%d%d",&n,&m)!=EOF,n+m)
{
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++)
{
map[i][j]=INF;
}
}
for(i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&t);
map[a][b]=map[b][a]=t;
}
Dijkstra(n,1);
printf("%d\n",dis[n]);
}
return 0;
}
bellman-ford未优化AC代码(主要为了理解概念):
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define INF 10000000
#define N 200000
int u[N],v[N],w[N];
int d[N];
int n,m;
void Bellman_ford()
{
for(int i=1;i<=n;i++)d[i]=INF;
d[1]=0;
for(int k=0;k<n;k++)
for(int i=1;i<=2*m;i++)//从dist(1)[u]递推出dist(2)[u], …,dist(n-1)[u] ,因为这是无向图,所以多检查了一些边
{
int x,y;
x=u[i];
y=v[i];
if(d[x]<INF)
d[y]=d[y]<d[x]+w[i]?d[y]:d[x]+w[i];
}
}
int main()
{
int i,j;
while(scanf("%d %d",&n,&m)!=EOF)
{
if(n==0&&m==0)break;
for(i=1;i<=2*m;i++){
scanf("%d %d %d",&u[i],&v[i],&w[i]);
int tempu = u[i];
int tempv = v[i];
int tempw = w[i];
u[++i] = tempv;
v[i] = tempu;
w[i] = tempw;
}
Bellman_ford();
printf("%d\n",d[n]);
}
return 0;
}
优化后代码:
#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 105
const int INF = 0x3fffffff;
struct Edge
{
int from,to,dist;
};
struct BellmanFord
{
int n,m;
vector<Edge> edges;
vector<int> G[maxn];
bool inq[maxn];
int d[maxn];
int p[maxn];
int cnt[maxn];
Edge e;
void init(int n)
{
this->n=n;
for(int i=0;i<n;i++)
G[i].clear();
edges.clear();
}
void AddEdge(int from,int to,int dist)
{
//printf("%d %d %d\n",from,to,dist);
edges.push_back((Edge){from,to,dist});
m=edges.size();
G[from].push_back(m-1);
}
bool negativeCycle()
{
queue<int >Q;
memset(inq,0,sizeof(inq));
memset(cnt,0,sizeof(cnt));
for(int i=0;i<n;i++)
{
d[i]=INF;
inq[0]=true;
Q.push(i);
}
d[0] = 0;
while(!Q.empty())
{
int u=Q.front();
Q.pop();
inq[u]=false;
for(int i=0;i<G[u].size();i++) //只检查存在的边
{
Edge& e=edges[G[u][i]];
if(d[e.to]>d[u]+e.dist)
{
d[e.to]=d[u]+e.dist;
p[e.to]=G[u][i];
if(!inq[e.to])
{
Q.push(e.to);
inq[e.to]=true;
if(++cnt[e.to]>n)
return true;
}
}
}
}
return false;
}
void To(){
printf("%d\n",d[n-1]);
}
};
int main()
{
int a,b,c,i,node,m;
bool j;
while(scanf("%d %d",&node,&m)!=EOF)
{
if(node==0&&m==0)break;
BellmanFord tu;
tu.init(node);
for(i=0;i<m;i++)
{
scanf("%d %d %d",&a,&b,&c);
a--;b--;
tu.AddEdge(a,b,c);
tu.AddEdge(b,a,c);
}
j=tu.negativeCycle();
tu.To();
}
return 0;
}