**
Dijkstra算法和Floyd算法求最短路径
**
第一次写博客同时记录自学数据结构Dijkstra算法和Floyd算法的过程。
Dijkstra算法是解决单元最短路径的比较有效一种方法，而Floyd算法是解决多源最短路径问题的方法。
先进行一些准备工作–定义
//采用邻接矩阵的方式存储图
//邻接矩阵的结构体定义
typedef struct{
ElemType **a; //邻接矩阵
int n; //图的当前顶点数
int e; //图的当前边数
ElemType noEdge; //两顶点间无边时的值
}mGraph;
//邻接矩阵的初始化
Status Init(mGraph *mg,int nSize,ElemType noEdgeValue){
int i,j;
mg->n=nSize; //初始化顶点数
mg->e = 0; //初始化时没有边
mg->noEdge = noEdgeValue; //初始化没有边时的取值
mg->a = (ElemType**)malloc(nSize*sizeof(ElemType *)); //生成长度为n的一维指针数组 ★★★★★
if(!mg->a) return ERROR;
for(i = 0;i < mg->n;i++){ //动态生成二维数组
mg->a[i] = (ElemType*)malloc(nSize*sizeof(ElemType));
for(j = 0;j < mg->n;j++){
mg->a[i][j] = mg->noEdge; //初始化时权重都设为INF
}
mg->a[i][i] = 0; //自回路设置为0
}
cout<<"初始化成功！"<<endl;
return OK;
}
//邻接矩阵的边的插入
Status Insert(mGraph *mg,int u,int v,ElemType w){
if(u < 0||v < 0||u > mg->n-1||v > mg->n-1 ||u == v) return ERROR;//u==v时不构成边
if(mg->a[u][v] != mg->noEdge) return Duplicate; //若待插入边已存在,则返回出错信息
mg->a[u][v] = w; //插入新边
mg->e ++; //增加一条边
return OK;
}
Dijkstra算法示例演示：
我们的主要思路如下：
- 我们用两个集合S和U进行操作，定义两个数组dist和path分别用于存储到源点的最短距离以及某点到源点最短距离的路径。同时我们初始化S集合为一个源点u，并更新dist和path数组的值。//path实际上是存储最短路径中每个结点的前驱，例如path[1]=0，在该最短路中，0是1的前驱。
- 接着我们从U集合中剩下的点中遍历出到源点距离最小的点并把它加入到S中，更新dist和path。这样一来，由于不断更新dist和path，我们可以保证每次加入的点到源点的距离最小，这条路径也就是最短路径。
- 重复2操作，直至U中没有剩余结点。
示例演示如下：
Dijkstra算法的代码如下：
//递归输出最短路径（用迭代也是可以的）
void outputpath(int path[],int st,int en)
{
if(en==st) {cout<<en<<" ";return;}
else {outputpath(path,st,path[en]);cout<<en<<" ";}
}
//狄克斯特拉算法
void Dijkstra(mGraph g,int v,int en)
{
int dist[MAXV],path[MAXV];
int s[MAXV];//用来构建图的集合，该集合中的任何点都已构建好最短路径的图，表示顶点i是否在其中
int mindis,i,j,u;
for(i=0;i<g.n;i++)
{
dist[i]=g.a[v][i];//图中各点到v的距离初始化
s[i]=0; //s[]置空
if(g.a[v][i]<INF) //路径初始化
path[i]=v; //顶点v到i有边
else
path[i]=-1; //顶点v到i没边
}
s[v]=1; //将起点v添加到s集合中
for(i=0;i<g.n;i++) //循环n-1次对剩下的顶点操作
{
mindis=INF;
for(j=0;j<g.n;j++)//这一遍循环后得到目前到原点最短距离的点的下标u，同时更新最短距离mindis
{
if(s[j]==0&&dist[j]<mindis)
{
u=j;
mindis=dist[j];
}
}
s[u]=1;
for(j=0;j<g.n;j++)//该循环用来修正不在s中的点到原点的最短距离
if(s[j]==0) //代表该点不在集合s中
if(g.a[u][j]<INF&&(dist[u]+g.a[u][j]<dist[j])) //u、j之间有路且从原点到u再到j的距离更短
{
dist[j]=dist[u]+g.a[u][j]; //修正最短路径
path[j]=u; //记录路径，j的前一个顶点u
}
}
cout<<"最短的路径为："<<endl;
outputpath(path,v,en);
}
Floyd算法示例演示如下：
（由于做图软件原因?，说明一下：1->2的权值为4，2->1=3，2->3=2，3->2=1)
我们的思路如下：
- 我们定义两个二维数组A[u][v]和path[i][j]，矩阵A存储点u到v的最短距离，path用来记录最短距离的路径。如path[i][j]存储的是起始点为i，终点为j的最短路径中，终点j的前驱结点。首先我们初始化矩阵A中直接相连边的距离，未直接相连的边我们初始化为∞(但这里无穷大的定义要防止溢出问题！！！起初定义矩阵A为int型，发现初始化出来的距离是负值，后来将A定义为longlong后解决了)，path同初始化为直接相连的两点的前驱，如path[0][1]=0。此时，事实上我们已经考虑了图中任意的2个点。
- 接着我们不断加入新的点k进行比较，如果我们先前加入的点u、v构成的路径u->…->v的距离不如我们从u先到k再到v短即u->…->k->…->v短，那么我们将k考虑进来后的距离和路径更新到A和path数组中。
这部分操作其实是通过遍历在每两个点之间进行的，我们可以理解成点与点之间不断连线再擦掉，最终保留最短的的线段形成了一条最短路径。
Floyd算法代码如下：
//floyd算法
void floyd(mGraph g) //O(n立方)
{
ll A[MAXV][MAXV]; //求每对顶点之间的最短路径
int path[MAXV][MAXV];//建立A数组
int i,j,k; //建立path数组
for(i=0;i<g.n;i++) //A和path数组的初始化
{ for(j=0;j<g.n;j++)
{
A[i][j]=g.a[i][j];
if(i!=j&&g.a[i][j]<INF)
path[i][j]=i;//i和j顶点之间有一条边时
else
path[i][j]=-1;//i和j顶点之间没有边
}
}
for(k=0;k<g.n;k++) //求Ak[i][j],即考虑了0-k个顶点后，i到j的最短距离。这个循环在依次考虑0-k个点
for(i=0;i<g.n;i++)
for(j=0;j<g.n;j++)
if(i!=j&&A[i][j]>A[i][k]+A[k][j])//找到更短路径即经过k的路径
{
A[i][j]=A[i][k]+A[k][j];//修改路径长度
path[i][j]=path[k][j]; //修改最短路经过k，即j的前一个顶点
}
cout<<"请输入起点编号v，以及终点编号u："<<endl;
int v,u;
cin>>v>>u;
cout<<"最短的路径为："<<endl;
outputpath(path,v,u);
}
完整代码如下：
#include <iostream>
#include<bits/stdc++.h>
#define ERROR 0
#define OK 1
#define Overflow 2 //表示上溢
#define Underflow 3 //表示下溢
#define NotPresent 4 //表示元素不存在
#define Duplicate 5 //表示有重复元素
#define MAXV 100
#define INF 0x7fffffff
#define ll long long
using namespace std;
typedef int ElemType;
typedef int Status;
//邻接矩阵的结构体定义
typedef struct{
ElemType **a; //邻接矩阵
int n; //图的当前顶点数
int e; //图的当前边数
ElemType noEdge; //两顶点间无边时的值
}mGraph;
//邻接矩阵的初始化
Status Init(mGraph *mg,int nSize,ElemType noEdgeValue){
int i,j;
mg->n=nSize; //初始化顶点数
mg->e = 0; //初始化时没有边
mg->noEdge = noEdgeValue; //初始化没有边时的取值
mg->a = (ElemType**)malloc(nSize*sizeof(ElemType *)); //生成长度为n的一维指针数组 ★★★★★
if(!mg->a) return ERROR;
for(i = 0;i < mg->n;i++){ //动态生成二维数组
mg->a[i] = (ElemType*)malloc(nSize*sizeof(ElemType));
for(j = 0;j < mg->n;j++){
mg->a[i][j] = mg->noEdge; //初始化时权重都设为INF
}
mg->a[i][i] = 0; //自回路设置为0
}
cout<<"初始化成功！"<<endl;
return OK;
}
//邻接矩阵的撤销(改成了int型，有返回值),先释放一维数组,再释放指针数组
int Destory(mGraph *mg){
int i;
for(i = 0;i < mg->n;i ++){
free(mg->a[i]); //释放n个一维数组的存储空间
}
free(mg->a); //释放一维指针数组的存储空间
cout<<"邻接矩阵已撤销!"<<endl;
return 1;
}
//邻接矩阵的边的搜索
Status Exist(mGraph *mg,int u,int v){
if(u < 0||v < 0||u > mg->n-1||v > mg->n-1 ||u == v||mg->a[u][v] == mg->noEdge) {cout<<"你所查找的边不存在!"<<endl;return ERROR;}
cout<<"查找成功！"<<endl;
return OK;
}
//邻接矩阵的边的插入
Status Insert(mGraph *mg,int u,int v,ElemType w){
if(u < 0||v < 0||u > mg->n-1||v > mg->n-1 ||u == v) return ERROR;//u==v时不构成边
if(mg->a[u][v] != mg->noEdge) return Duplicate; //若待插入边已存在,则返回出错信息
mg->a[u][v] = w; //插入新边
mg->e ++; //增加一条边
return OK;
}
//邻接矩阵的边的删除
Status Remove(mGraph *mg,int u,int v){
if(u < 0||v < 0||u > mg->n-1||v > mg->n-1 ||u == v) {cout<<"你的输入有误！"<<endl;return ERROR;}
if(mg->a[u][v] == mg->noEdge) {cout<<"你所要删除的边不存在!"<<endl;return ERROR;} //若待删除边不存在,则返回出错信息
mg->a[u][v] = mg->noEdge; //删除边
mg->e --;
cout<<"删除成功！"<<endl;
return OK;
}
//递归输出最短路径
void outputpath(int path[],int st,int en)
{
if(en==st) {cout<<en<<" ";return;}
else {outputpath(path,st,path[en]);cout<<en<<" ";}
}
//狄克斯特拉算法
void Dijkstra(mGraph g,int v,int en)
{
int dist[MAXV],path[MAXV];
int s[MAXV];//用来构建图的集合，该集合中的任何点都已构建好最短路径的图，表示顶点i是否在其中
int mindis,i,j,u;
for(i=0;i<g.n;i++)
{
dist[i]=g.a[v][i];//图中各点到v的距离初始化
//cout<<i<<": "<<dist[i]<<endl;;
s[i]=0; //s[]置空
if(g.a[v][i]<INF) //路径初始化
path[i]=v; //顶点v到i有边
else
path[i]=-1; //顶点v到i没边
}
s[v]=1; //将起点v添加到s集合中
for(i=0;i<g.n;i++) //循环n-1次对剩下的顶点操作
{
mindis=INF;
for(j=0;j<g.n;j++)//这一遍循环后得到目前到原点最短距离的点的下标u，同时更新最短距离mindis
{
if(s[j]==0&&dist[j]<mindis)
{
u=j;
mindis=dist[j];
}
}
s[u]=1;
for(j=0;j<g.n;j++)//该循环用来修正不在s中的点到原点的最短距离
if(s[j]==0) //代表该点不在集合s中
if(g.a[u][j]<INF&&(dist[u]+g.a[u][j]<dist[j])) //u、j之间有路且从原点到u再到j的距离更短
{
dist[j]=dist[u]+g.a[u][j]; //修正最短路径
path[j]=u; //记录路径，j的前一个顶点u
}
}
cout<<"最少转乘次数的路径为："<<endl;
outputpath(path,v,en);
}
//floyd算法
void floyd(mGraph g) //O(n立方)
{
ll A[MAXV][MAXV]; //求每对顶点之间的最短路径
int path[MAXV][MAXV];//建立A数组
int i,j,k; //建立path数组
for(i=0;i<g.n;i++) //A和path数组的初始化
{ for(j=0;j<g.n;j++)
{
A[i][j]=g.a[i][j];
if(i!=j&&g.a[i][j]<INF)
path[i][j]=i;//i和j顶点之间有一条边时
else
path[i][j]=-1;//i和j顶点之间没有边
}
}
for(k=0;k<g.n;k++) //求Ak[i][j],即考虑了0-k个顶点后，i到j的最短距离。这个循环在依次考虑0-k个点
for(i=0;i<g.n;i++)
for(j=0;j<g.n;j++)
if(i!=j&&A[i][j]>A[i][k]+A[k][j])//找到更短路径即经过k的路径
{
A[i][j]=A[i][k]+A[k][j];//修改路径长度
path[i][j]=path[k][j]; //修改最短路经过k，即j的前一个顶点
}
cout<<"请输入起始城市的编号v，以及终点城市编号u："<<endl;
int v,u;
cin>>v>>u;
cout<<"最少转乘次数的路径为："<<endl;
outputpath(path[v],v,u);
}
int main()
{
mGraph g;
int i,j,u,v;
int n,m;
cout<<"请输入城市的数量："<<endl;
cin>>n;
Init(&g,n,INF);
cout<<"请输入航线的数量："<<endl;
cin>>m;
cout<<"请输入"<<m<<"条航线各自的起点和终点："<<endl;
for(i=0;i<m;i++)
{
cin>>u>>v;
Insert(&g,u,v,1);
}
cout<<endl<<"下面采用dijkstra算法："<<endl;
cout<<"请输入起始城市的编号v，以及终点城市编号u："<<endl;
cin>>v>>u;
Dijkstra(g,v,u);
cout<<endl<<"下面采用floyd算法："<<endl;
floyd(g);
system("pause");
return 0;
}
下面是飞机转乘问题样例的调试（因为初始化时各条边的权值均初始化为1，故最终结果与上图样例有些出入，可在insert函数调用时增加输入权值）
代码暂时应该没有什么大的问题，第一次blog完美收官（哈哈哈哈哈哈哈哈哈哈哈哈）
1285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
