图的更多相关算法-2（最短路径）

void DispPath(int path[],int begin, int end)               //此函数是输出从begin节点到end节点最短的路径
{
int ivar = 0;
ivar = path[end];
cout<<"path is :"<<end<<' ';
while(ivar != 0)
{
cout<<ivar<<' ';
ivar = path[ivar];
}
cout<<begin<<endl;
}

/*
此算法求节点距离其他节点的最短距离
s[i] == 1数组表示节点i在 s中不再 U中
dist[i]数组保存从begin到i节点的路径最小值
path[i]数组保存的是路径中在i节点前面的节点的值
思路:
在dist数组中查找在s数组中最短的路径的值，把找到的节点当做中间节点， 如果通过中间节点的路径比直达的路径或原先的路径短就进行替换
整个查找中间节点的操作是在dist数组中进行的

此算法与普利姆算法的区别是当找到中间节点后，此算法会由中间节点计算权的值，并进行相关的计算
而普利姆算法则是利用中间的修正候选边

普利姆算法中的lowcost保存的是两个顶点之间的最短路径
而狄更拉斯算法中的  dist数组保存的是初始顶点到其他顶点之间的最短路径，中间可以有节点存在即不是直达的节点
*/
void Dijkstra(MGraph mg, int begin)
{
int loop1 = 0, count = 0, min = 1000, node = 0, path[MAXSIZE]; //path[i] 保存的是从begin 到i的路径中，位于 i前面的一个节点的值
int s[MAXSIZE], dist[MAXSIZE];                              //s数组用以说明顶点的位置，当s[i] == 1的时候，说明顶点i在s中， 当s[i] == 0 的时候说明顶点在U中
//dist[i]数组用以保存从顶点begin 到 顶点为i的最短距离
for(loop1 = 0; loop1 < MAXSIZE; ++loop1)
s[loop1] = 0;
s[begin] = 1;

for(loop1 = 0; loop1 < mg.n; ++loop1)
{
dist[loop1] = mg.edges[begin][loop1];                   //dist[i] == 0的话，表示从 顶点begin 到 i节点不可到达
if(mg.edges[begin][loop1] == 0)                         //此处为path赋初值，如果begin到节点loop1可直达，则path为0 代表这个路径的前一个节点是begin节点本身， 否则的话path初始化为-1 ，代表没有路径
{   path[count] = -1; ++count; }
else
{   path[count] =  0; ++count; }
}
path[begin] = 0;
count = 1;

while(count < mg.n)
{
min = 1000;
for(loop1 = 0; loop1 < mg.n; ++loop1)               //此处进行查找最短的路径，条件是节点在U中，并且从begin到节点必须可以到达
{
if(s[loop1] == 0 && dist[loop1] != 0 && min > dist[loop1])
{
min  = dist[loop1];
node = loop1;
}
}
cout<<"Visiting node  "<<node<<endl;

s[node] = 1;                                        //node为找到的节点
for(loop1 = 1; loop1 < mg.n; ++loop1)               //此步骤是以找到的node节点为点，循环遍历与node直接相邻的量
{
if(node != loop1 && mg.edges[node][loop1] != 0)//条件是不遍历自己， 并且那个节点与node节点应该可直达
{
if(dist[loop1] == 0  )                     //此处表示如果begin节点到loop1节点不能直达的话，就直接把经过node节点的距离当做最短距离
{   dist[loop1] = dist[node] + mg.edges[node][loop1];  path[loop1] = node;}
else if((dist[node] + mg.edges[node][loop1] ) < dist[loop1])        //否则的话，就进行判断如果进过node节点的路径长度小于直达的路径长度，进把距离的值重新赋值
{   dist[loop1] = dist[node] + mg.edges[node][loop1];  path[loop1] = node;}
}
}
++count;
}

for(loop1 = 0; loop1 < mg.n; ++loop1)
{
cout<<"shortest path to "<<loop1<<" is "<<dist[loop1]<<endl;
}
DispPath(path,begin,6);
}

/*
采用弗洛伊德算法求每对顶点之间的最短路径
A[i][j]数组用以保存从i节点到j节点之间的最短路径，初始的值为顶点之间的权值
path[i][j]数组用以保存上一个节点的编号，即中间节点的编号，初始化的值为-1，表示没有中间节点

其步骤是：
1. 确定顶点i到j之间是否有通过0节点的路径，如果有的话，此时表示A[i][0] != 0  A[0][j] != 0 成立，然后判断这两段的长度是否比直达的长度小，如果小的话，就进行最短路径的替换（A数组保存的最短的路径），同时把path数组相应的节点置为0，表示从节点i到节点j之间存在一个中间节点为0
2. 考察顶点i到j之间是否有通过1节点的路径，如果有的话，即按照上面的步骤进行，否则直接跳过
3. 重复上述步骤2

通过比较知道：狄克斯特拉算法是求某个特定的顶点到其余顶点之间的最短路径    此算法表现的是特定的顶点与其余顶点之间的关系
而弗洛伊德算法则是求每对顶点之间的最短路径                   此算法表现的是定点与顶点的关系
*/

void Floyd(MGraph mg)
{
int path[MAXSIZE][MAXSIZE], A[MAXSIZE][MAXSIZE];        //path[i][j]数组保存的是从顶点i到顶点j中间节点编号不大于k的路径的上一个节点的编号
int ivar = mg.n, loop1 = 0, loop2 = 0, loop3 = 0;                                                             //A[i][j]数组保存的是从i到j的最短距离

for(loop1 = 0; loop1 < ivar; ++loop1)
for(loop2 = 0; loop2 < ivar; ++loop2)
{
path[loop1][loop2] = -1;
A[loop1][loop2]    = mg.edges[loop1][loop2];                          //对A数组进行初始化为边的权值，0表示两个顶点之间不可以直达或没路径
}

for(loop1 = 0; loop1 < ivar; ++loop1)
{   for(loop2 = 0; loop2 < ivar; ++loop2)
for(loop3 = 0; loop3 < ivar; ++loop3)
{//此处应该以A数组为对象，不应该以mg.edges数组为对象。
//  if(loop2 != loop3 && mg.edges[loop2][loop1] != 0 && mg.edges[loop1][loop3] != 0 && (A[loop2][loop3] == 0 || (mg.edges[loop2][loop1] + mg.edges[loop1][loop3]) < A[loop2][loop3]))
if(loop2 != loop3 && A[loop2][loop1] != 0 && A[loop1][loop3] != 0 && (A[loop2][loop3] == 0 || (A[loop2][loop1] + A[loop1][loop3]) < A[loop2][loop3]))
{
A[loop2][loop3]    = A[loop2][loop1] + A[loop1][loop3];
path[loop2][loop3] = loop1;
}
}
for(loop2 = 0; loop2 < ivar; ++loop2)
{   for(loop3 = 0; loop3 < ivar; ++loop3)
cout<<A[loop2][loop3]<<' ';
cout<<endl;
}
cout<<endl;
}
}

void MinTree(MGraph mg,int begin)
{
int dist[MAXSIZE], path[MAXSIZE], v[MAXSIZE];
int loop1 = 0, count = 1,node = 0, min = 10000, pre = 0,ivar = mg.n;

for(loop1 = 0; loop1 < ivar; ++loop1)
{
v[loop1]    = 0;
dist[loop1] = mg.edges[begin][loop1];
if(mg.edges[begin][loop1] != 0)
{ path[loop1] = begin; }
else
{ path[loop1] = -1; }
}

v[begin] = 1;
count    = 1;
while(count < ivar)
{
min = 10000;
for(loop1 = 0; loop1 < ivar; ++loop1)
{
if(v[loop1] == 0 && dist[loop1] != 0 && min > dist[loop1])
{
node = loop1;
min  = dist[loop1];
}
}
v[node] = 1;
for(loop1 = 0; loop1 < ivar; ++loop1)
{
if(mg.edges[node][loop1] != 0 && (dist[loop1] == 0 || (dist[node] + mg.edges[node][loop1]) < dist[loop1] ))
{
dist[loop1] = mg.edges[node][loop1]  + dist[node];
path[loop1] = node;
}
}
++count;
}

for(loop1 = 0; loop1 < ivar; ++loop1)
{
if(v[loop1] == 1 && loop1 != begin)
{
pre = path[loop1];
cout<<"line is "<<pre<<" to "<<loop1<<" weight is "<<mg.edges[pre][loop1]<<endl;
}
}
}

void Centerp(MGraph mg)
{
int loop1 = 0, loop2 = 0, loop3 = 0, max = -1, maxindex = 0, ivar = mg.n;
int A[MAXSIZE][MAXSIZE], path[MAXSIZE][MAXSIZE];

for(loop1 = 0; loop1 < ivar; ++loop1)
for(loop2 = 0; loop2 < ivar; ++loop2)
{
A[loop1][loop2]    = mg.edges[loop1][loop2];
path[loop1][loop2] = -1;
}
for(loop1 = 0; loop1 < ivar; ++loop1)
for(loop2 = 0; loop2 < ivar; ++loop2)
for(loop3 = 0; loop3 < ivar; ++loop3)
{
if(A[loop2][loop1] != 0 && A[loop1][loop3] != 0 && (A[loop2][loop3] == 0 || (A[loop2][loop1] + A[loop1][loop3]) < A[loop2][loop3]) )
{
A[loop2][loop3]    = A[loop2][loop1] + A[loop1][loop2];
path[loop2][loop3] = loop1;
}
}
for(loop1 = 0; loop1 < ivar; ++loop1)
{
for(loop2 = 0; loop2 < ivar; ++loop2)
{
if(max < A[loop2][loop1])
{
max      = A[loop2][loop1];
maxindex = loop1;
}
}
}
cout<<"the center node is : "<<maxindex<<endl;
}