图论 回顾最短路写法(Dijktra和Floyd)

下面是Dijkstra算法求最短路

/*
严格参照《数据结构(严蔚敏版)》
2017.12.6
by kk
*/

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<cmath>
#include<algorithm>
#define infinity 0x3f3f3f3f
#define maxsize 100
using namespace std;
typedef int VertexType;
typedef int ElemType;
typedef char InfoType;
typedef int shortPathTable[maxsize];
typedef int pathMatrix[maxsize];
typedef struct
{
ElemType data;
InfoType info;
} Matrix;
typedef struct
{
VertexType ver[maxsize];
Matrix arc[maxsize][maxsize];
int numVer,numEdge;
int kind;
} GraphM;
void createMatrix(GraphM &g)
{
scanf("%d%d",&g.numVer,&g.numEdge);
int i,j;
for(i=0; i<g.numVer; i++)
scanf("%d",&g.ver[i]);
for(i=0; i<g.numVer; i++)
for(j=0; j<g.numVer; j++)
g.arc[i][j].data=infinity;
int x,y,w;
for(i=0; i<g.numEdge; i++)
{
scanf("%d%d%d",&x,&y,&w);
g.arc[x][y].data=w;
g.arc[y][x].data=w;
}
}//以上是在建邻接矩阵，具体解释就看以前的文章了
void shortestPath_Dijkstra(GraphM G,int x,pathMatrix &P,shortPathTable &D)
{
/*
其实感觉dijkstra算法跟prim求最小生成树算法差不多
这里的P数组就相当于adjvex数组，D数组就相当于lowcost数组，final数组的作用跟
vis的数组作用一样.其实prim中也是有vis数组的，只是用lowcost数组代替了，lowcost数组
有两个作用，一个是标记哪个点已经选取了，一个是当前可选择边的长度。

*/
int i,j;

int Final[maxsize];
memset(Final,0,sizeof(Final));
for(i=0; i<G.numVer; i++)
P[i]=x;//所有节点都是从x出发
Final[x]=1;//x结点已经到过了
for(i=0; i<G.numVer; i++)
D[i]=G.arc[x][i].data;
//开始只有x结点，那么到各点的距离就由x决定，当加入其他点后，就得由几个点一起决定，
//即下面for循环代码做的工作

D[x]=0;//自己到自己当然距离为0
int Min,k;
for(i=1; i<G.numVer; i++)
{
Min=infinity;
for(j=0; j<G.numVer; j++)
if(!Final[j]&&D[j]<Min)
{
Min=D[j];
k=j;
}
Final[k]=1;
for(j=0; j<G.numVer; j++)
{
if(!Final[j]&&(Min+G.arc[k][j].data)<D[j])
{
D[j]=Min+G.arc[k][j].data;
P[j]=k;
}
}
}

printf("pathMatrix[]:\n");
for(i=0; i<G.numVer; i++)
printf("%3d ",P[i]);
puts("");
printf("shortPathTable[]:\n");
for(i=0; i<G.numVer; i++)
printf("%3d ",D[i]);
puts("");

//get path
/*
int path_count=0;
int v0=x;
int path[maxsize];
path[path_count++]=8;
int r=8;
while(P[r]!=x){
path[path_count++]=P[r];
r=P[r];
}
path[path_count++]=x;
for(i=path_count-1;i>=0;--i)
printf("%d ",path[i]);
printf("\n");
*/
}
int main()
{
GraphM G;
createMatrix(G);
pathMatrix P;
shortPathTable D;
shortestPath_Dijkstra(G,0,P,D);

return 0;
}
/*

/*
5 6
0 1 2 3 4
0 1 9
0 2 2
0 4 6
1 2 3
2 3 5
3 4 1

9 16
0 1 2 3 4 5 6 7 8
0 1 1
0 2 5
1 2 3
1 4 5
1 3 7
2 4 1
2 5 7
3 4 2
3 6 3
4 6 9
4 5 3
4 7 9
5 7 5
6 7 2
6 8 7
7 8 4
*/



下面是弗洛伊德算法求zuiduanl
/*
严格参照《数据结构(严蔚敏版)》
2017.12.6
by kk
*/

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<cmath>
#include<algorithm>
#define infinity 0x3f3f3f3f
#define maxsize 100
using namespace std;
typedef int VertexType;
typedef int ElemType;
typedef char InfoType;
typedef int shortPathTable[maxsize][maxsize];
typedef int pathMatrix[maxsize][maxsize];
typedef struct
{
ElemType data;
InfoType info;
} Matrix;
typedef struct
{
VertexType ver[maxsize];
Matrix arc[maxsize][maxsize];
int numVer,numEdge;
int kind;
} GraphM;
void createMatrix(GraphM &g)
{
scanf("%d%d",&g.numVer,&g.numEdge);
int i,j;
for(i=0; i<g.numVer; i++)
scanf("%d",&g.ver[i]);
for(i=0; i<g.numVer; i++)
for(j=0; j<g.numVer; j++)
g.arc[i][j].data=infinity;
int x,y,w;
for(i=0; i<g.numEdge; i++)
{
scanf("%d%d%d",&x,&y,&w);
g.arc[x][y].data=w;
g.arc[y][x].data=w;
}
}
//以上是邻接矩阵建图，以前的文章有详细解释

void shortestPath_Floyd(GraphM G,pathMatrix &P,shortPathTable &D)
{
int i,j,k;
for(i=0; i<G.numVer; i++)//首先对D矩阵和P矩阵进行初始化
for(j=0; j<G.numVer; j++)
{
D[i][j]=G.arc[i][j].data;
P[i][j]=j;
}
//D矩阵用原始邻接矩阵初始化，P矩阵用坐标的j坐标初始化
//ShortPathTable矩阵(即D矩阵)里[v][w]代表v到w的最短距离，P矩阵用来记录路径

//以下是三层循环
for(k=0; k<G.numVer; k++)//第一层
{

for(i=0; i<G.numVer; i++)//第二和第三层是在遍历整个D矩阵
{
for(j=0; j<G.numVer; j++)
{
if(D[i][j]>(D[i][k]+D[k][j]))
{
D[i][j]=D[i][k]+D[k][j];
P[i][j]=P[i][k];
}
}
}
//如果发现D[i][j]>(D[i][k]+D[k][j])那么就D[i][j]将改为D[i][k]+D[k][j]

}

}
void showPath(GraphM G,pathMatrix P,shortPathTable D,int x,int y)
{
//打印路径时，在PathMatirx矩阵里找x到y路径时，就找到y那一列进行操作，比如说0->8,则从p[0][8]
//开始
int i,j;
printf("%d-%d %d\n",x,y,D[x][y]);
int k=P[x][y];
printf("path:%d ",x);
while(k!=y)
{
printf("%d ",k);
k=P[k][y];
}
printf("%d\n",y);

}
int main()
{
//Floyd算法是可以求多源点最短路的，Dijktra算法是单源点的
GraphM G;
createMatrix(G);
shortPathTable D;
pathMatrix P;
shortestPath_Floyd(G,P,D);
showPath(G,P,D,0,8);
showPath(G,P,D,1,7);
return 0;
}
/*

/*
5 6
0 1 2 3 4
0 1 9
0 2 2
0 4 6
1 2 3
2 3 5
3 4 1

9 16
0 1 2 3 4 5 6 7 8
0 1 1
0 2 5
1 2 3
1 4 5
1 3 7
2 4 1
2 5 7
3 4 2
3 6 3
4 6 9
4 5 3
4 7 9
5 7 5
6 7 2
6 8 7
7 8 4
*/