目录
- 最短路径 (*)
- 迪杰斯特拉算法(Dijkstra)
- 迪杰斯特拉算法(Dijkstra)的算法原理:
- 弗洛伊德算法(Floyd)
- 弗洛伊德算法(Floyd)的算法原理:
- 弗洛伊德算法的(c语言)完整实例:
最短路径 (*)
生活中最短路径问题例如:
交通网络:给定了该网内的n个城市以及这些市之间的相通公路的距离,能否找到城市A城市B之间一条最近的通路呢?
- 从A地到B地换车次数最少的路径
- 从A地到B地最短的路径(距离最短,行驶时间最短,费用最低)
- 迪杰斯特拉(Dijkstra)算法–从一个源点到其它各点的最短路径
- 弗洛伊德(Floyd)算法–每一对顶点之间的最短路径
- Bellman-Ford算法
迪杰斯特拉算法(Dijkstra)
该算法只适用于静态网络网络上边的权值不能为负数
基本思想:设集合S
中存放已找到最短路径的顶点,集合 T = V − S T =V-S T=V−S存放当前还未找到最短路径的顶点。
1.初态: S中 只包含源点 v0
,v0
到其余 各点的弧 为各点当前各点
的“最短”路径。
2.从T
中选取当前各点的“最短”路径长度中最短的顶点u
加入到S
中。
3.S
加入新的顶点u
后,考察顶点 v 0 v_0 v0到T
中剩余顶点的最短路径长度是否可以优化更新:T中各顶点新的最短路径长度值为原来的最短路径长度值、顶点u
的最短路径长度值加上u
到该顶点的路径长度值中的较小值。
4.重复2,3,直到T
的顶点全部加入到S
中、或源点到剩余顶点的路径都是∞
为止。
一、图的存储:邻接矩阵和邻接表都可以
#define max 100
typedef struct {int arcs[max][max];int vexnum,arcnum;
}AGraphs;
Agraphs G;//定义图存储结构 邻接矩阵的存储形式
二、区分已经求出最短路径的点
方法一:设一个一维数组int final[max];
final[i]=1
表示从源点到顶点i
的最短路径已经求出,i
在S
中
final[i]=0
表示从源点到顶点i
的最短路径尚未求出,i
在V-S
中
方法二:利用邻接矩阵主对角线
的位置G.arcs[i][i]
表示i
是否在S
中
G.arcs[i][i]=1
表示从源点到顶点i
的最短路径已经求出
,i
在S
中
G.arcs[i][i]=0
表示从源点到顶点i
的最短路径尚未求出
,i
在V-S
中
三、表示源点到顶点i的最短路径
一维数组int D[max]
表示最短路径的长度
D[i]
:从源点到点 v i v_i vi的最短路径的长度
初态为:若从源点 到 v i v_i vi有弧,则D[i]
为弧上的权值;否则置 D[i]
为∞
,即:D[i]=G.arcs[k][i]
; //说明:k为源点
二维数组int P[max][max]
表示最短路径包含的顶点
P[i][ ]
:从源点到点 v i v_i vi的最短路径
P[i][j]=0
: v j v_j vj不在从源点 到点 v i v_i vi的最短路径上
P[i][j]=1
: v j v_j vj位于从源点 到点 v i v_i vi的最短路径上。
迪杰斯特拉算法(Dijkstra)的算法原理:
void ShortestPath(AGraphs G,int k,int P[][], int D[]){ int i,w, j,min;for (i=0;i<G.vexnum; i ++){ final[i]=0; //初始化D[i]=G.arcs[k][i];//最短路径长度for(w=0;w<G.vexnum; w ++) P[i][w]=0;//初始化if (D[i]<INFINITY){ //短路径包含的顶点P[i][k]=1; P[i][i]=1; }}D[k]=0; //初始点final[k]=1;for(i=1; i<G.vexnum; i ++){ min=INFINITY;//初始化为 无穷大for (w=0;w<G.vexnum; w ++)if (!final[w]&&D[w]<min){//j=w; min=D[w];} if(min== INFINITY) //return;final[j]=1; //标记为选入for(w=0;w<G.vexnum; w ++)if(!final[w]&&(min+G.arcs[j][w]<D[w])){ D[w]=min+G.arcs[j][w];P[w]=P[j]; //??P[w][w]=1; }}
弗洛伊德算法(Floyd)
图的存储:邻接矩阵和邻接表都可以
#define max 100
typedef struct {int arcs[max][max];int vexnum,arcnum;
}AGraphs;
Agraphs G;//定义图存储结构 邻接矩阵的存储形式
弗洛伊德算法(Floyd)的算法原理:
void s1(int D[][],int p[][][], Agraphs G){ int i,j,k;for(i=0;i<G. vexnum;i++) for(j=0;j<G. vexnum;j++){ D[i][j]=G.arcs[i][j];for(k=0;k<G.vnum;k++) p[i][j][k]=0; //初始化if(D[i][j]<INFINITY){ p[i][j][i]=1; //初始化p[i][j][j]=1; //初始化}}for (k=0;k<G. vexnum;k++) for (i=0;i<G. vexnum;i++)for(j=0;j<G vexnum;j++) if(D[i][k]+D[k][j]<D[i][j]){//是否K 加入能够减小路径长度D[i][j]=D[i][k]+D[k][j];//如果可以 就加入for(w=0;w<G. vexnum;w++) p[i][j][w]=p[i][k][w]||p[k][j][w];//然后确定路径上的元素}
}
弗洛伊德算法的(c语言)完整实例:
//算法6.11 弗洛伊德算法#include <iostream>
using namespace std;#define MaxInt 32767 //表示极大值,即∞
#define MVNum 100 //最大顶点数typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType; //假设边的权值类型为整型 int Path[MVNum][MVNum]; //最短路径上顶点vj的前一顶点的序号
int D[MVNum][MVNum]; //记录顶点vi和vj之间的最短路径长度//------------图的邻接矩阵---------------
typedef struct{ VerTexType vexs[MVNum]; //顶点表 ?ArcType arcs[MVNum][MVNum];//邻接矩阵 int vexnum,arcnum; //图的当前点数和边数
}AMGraph;int LocateVex(AMGraph G , VerTexType v){//确定点v在G中的位置for(int i = 0; i < G.vexnum; ++i)if(G.vexs[i] == v)return i;return -1;
}//LocateVexvoid CreateUDN(AMGraph &G){ //采用邻接矩阵表示法,创建有向网G int i , j , k;//cout <<"请输入总顶点数,总边数,以空格隔开:";cin >> G.vexnum >> G.arcnum; //输入总顶点数,总边数//cout << "输入点的名称,如a" << endl;for(i = 0; i < G.vexnum; ++i){ //cout << "请输入第" << (i+1) << "个点的名称:";cin >> G.vexs[i]; //依次输入点的信息 }for(i = 0; i < G.vexnum; ++i){ //初始化邻接矩阵,边的权值均置为极大值MaxInt for(j = 0; j < G.vexnum; ++j){ if(j != i)G.arcs[i][j] = MaxInt; elseG.arcs[i][j] = 0;}//for}//for //初始化//cout << "输入边依附的顶点及权值,如a b 3" << end;for(k = 0; k < G.arcnum;++k){ //构造邻接矩阵 VerTexType v1 , v2;ArcType w;//cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值i = LocateVex(G, v1); j = LocateVex(G, v2); //确定v1和v2在G中的位置,即顶点数组的下标 G.arcs[i][j] = w; //边<v1, v2>的权值置为w }//for
}//CreateUDN /*
【样例输入】4 5A B C D A B 2 A C 4B C 3B D 5C D 1A D【样例输出】5*/void ShortestPath_Floyed(AMGraph G){ int i, j, k;for( i=0;i<G.vexnum;i++ ){for( j=0;j<G.vexnum;j++ ){D[i][j] = G.arcs[i][j]; // 距离矩阵初始化Path[i][i] = i; // 路径矩阵初始化if(G.arcs[i][j]!=MaxInt){Path[i][j]=i;}}}for( k=0;k<G.vexnum;k++ ) {for( i=0;i<G.vexnum;i++ ){for( j=0;j<G.vexnum;j++ ){if( D[i][k] + D[k][j] < D[i][j] ){D[i][j] = D[i][k] + D[k][j]; // 动态更新距离矩阵Path[i][j] = Path[k][j]; // 动态更新路径矩阵}}}}//test 看每个矩阵的结果// printf("\nG.arc矩阵的结果如下:\n");// for( i=0;i<G.vexnum;i++ ) // 输出// {// for( j=0;j<G.vexnum;j++ )// {// printf("%d ",G.arcs[i][j]);// }// printf("\n");// }// printf("\n距离矩阵的结果如下:\n");// for( i=0;i<G.vexnum;i++ ) // 输出// {// for( j=0;j<G.vexnum;j++ )// {// printf("%d ",D[i][j]);// }// printf("\n");// }// printf("\n路径矩阵的结果如下:\n");// for( i=0;i<G.vexnum;i++ ) // 输出// {// for( j=0;j<G.vexnum;j++ )// {// printf("%d ",Path[i][j]);// }// printf("\n");// }}void DisplayPath(AMGraph G , int begin ,int temp ){//显示最短路径if(Path[begin][temp] != -1){DisplayPath(G , begin ,Path[begin][temp]);cout << G.vexs[Path[begin][temp]] << "-->";}
}//DisplayPathint main(){//cout << "************算法6.11 弗洛伊德算法**************" << endl << endl;AMGraph G;char start , destination;int num_start , num_destination;CreateUDN(G);//test//cout << "有向网G创建完成!" << endl;//test//需要完成的函数ShortestPath_Floyed(G);//需要完成的函数//test//cout << "请依次输入路径的起点与终点的名称:";//testcin >> start >> destination;num_start = LocateVex(G , start);num_destination = LocateVex(G , destination);//DisplayPath(G , num_start , num_destination);//cout << G.vexs[num_destination] << endl;cout << D[num_start][num_destination] << endl;return 0;
}//main