弗洛伊德算法最短路径

A. 弗洛伊德算法可以解决无向图最短路径么

可以的，弗洛伊德算法利用动态规划解决了无向图中任意两个点之间的最短路径，时间复杂度是O(n^3)，n是图中点个数
同时可以使用狄杰斯卡拉算法解决无向图的最短路径问题，他计算的是图中指定点到其余各点的最短路径，时间复杂度是O(n^2)

B. 用弗洛伊德算法求最短路径

是地信的题吧，先给你说v1怎么求，
先找出v1能去的最近的点，为V2，
如果S1i>S12+S2i
修改V1到Vi的距离为S12+S2i
然后去掉V2，在其余的点中找距V1最近的，按上面的方法修改
最后得到V1与其他各点的最短距离
同样的方法求出到其他点的最短距离

C. 为什么floyd算法可以计算负权值图的最短路径问题

弗洛伊德算法：Dis(i,j) =min(Dis(i,j), Dis(i,k) + Dis(k,j)).
我是这么理解的，Dis(i,k)或Dis(k,j)可以有一条边是负的，只要两者之和不是负的就行，因为两个和为负就会选取到这个组合，但是路径的结果不应该是负的。Dijkstra中S(已求出解)中的每一个点解即最短路径是已求出的,若存在负数路径,可能存在已求出的解不是最优解.

D. 用Floyd算法求有向网G中各对顶点之间的最短路径

#define MAX_NAME 5 // 顶点字符串的最大长度+1
#define MAX_INFO 20 // 相关信息字符串的最大长度+1
typedef int VRType;
typedef char VertexType[MAX_NAME];
typedef char InfoType;
#include"c1.h"
#include"c7-1.h"
#include"bo7-1.cpp"
typedef int PathMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef int DistancMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; void ShortestPath_FLOYD(MGraph G,PathMatrix &P,DistancMatrix &D)
{ // 用Floyd算法求有向网G中各对顶点v和w之间的最短路径P[v][w]及其
// 带权长度D[v][w]。若P[v][w][u]为TRUE,则u是从v到w当前求得最短
// 路径上的顶点。
int u,v,w,i;
for(v=0;v<G.vexnum;v++) // 各对结点之间初始已知路径及距离
for(w=0;w<G.vexnum;w++)
{
D[v][w]=G.arcs[v][w].adj;
for(u=0;u<G.vexnum;u++)
P[v][w][u]=FALSE;
if(D[v][w]<INFINITY) // 从v到w有直接路径
{
P[v][w][v]=TRUE;
P[v][w][w]=TRUE;
}
}
for(u=0;u<G.vexnum;u++)
for(v=0;v<G.vexnum;v++)
for(w=0;w<G.vexnum;w++)
if(D[v][u]+D[u][w]<D[v][w]) // 从v经u到w的一条路径更短
{
D[v][w]=D[v][u]+D[u][w];
for(i=0;i<G.vexnum;i++)
P[v][w][i]=P[v][u][i]||P[u][w][i];
}
} void main()
{
MGraph g;
int i,j,k,l,m,n;
PathMatrix p;
DistancMatrix d;
CreateDN(g);
for(i=0;i<g.vexnum;i++)
g.arcs[i][i].adj=0; // ShortestPath_FLOYD()要求对角元素值为0
printf("邻接矩阵:\n");
for(i=0;i<g.vexnum;i++)
{
for(j=0;j<g.vexnum;j++)
printf("%11d",g.arcs[i][j]);
printf("\n");
}
ShortestPath_FLOYD(g,p,d);
printf("d矩阵:\n");
for(i=0;i<g.vexnum;i++)
{
for(j=0;j<g.vexnum;j++)
printf("%6d",d[i][j]);
printf("\n");
}
for(i=0;i<g.vexnum;i++)
for(j=0;j<g.vexnum;j++)
printf("%s到%s的最短距离为%d\n",g.vexs[i],g.vexs[j],d[i][j]);
printf("p矩阵:\n");
l=strlen(g.vexs[0]); // 顶点向量字符串的长度
for(i=0;i<g.vexnum;i++)
{
for(j=0;j<g.vexnum;j++)
{
if(i!=j)
{
m=0; // 占位空格
for(k=0;k<g.vexnum;k++)
if(p[i][j][k]==1)
printf("%s",g.vexs[k]);
else
m++;
for(n=0;n<m*l;n++) // 输出占位空格
printf(" ");
}
else
for(k=0;k<g.vexnum*l;k++) // 输出占位空格
printf(" ");
printf(" "); // 输出矩阵元素之间的间距
}
printf("\n");
}
}

E. floyd算法求最短路径

Floyd算法适用于APSP(AllPairsShortestPaths)，是一种动态规划算法，稠密图效果最佳，边权可正可负。此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法。

优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单

缺点：时间复杂度比较高，不适合计算大量数据。

时间复杂度:O(n^3)；空间复杂度:O(n^2)；

任意节点i到j的最短路径两种可能：

直接从i到j；
从i经过若干个节点k到j。
map（i，j）表示节点i到j最短路径的距离，对于每一个节点k，检查map（i，k）+map（k，j）小于map(i，j),如果成立，map（i，j） = map（i，k）+map（k，j）；遍历每个k，每次更新的是除第k行和第k列的数。

步骤：

第1步：初始化map矩阵。
矩阵中map[i][j]的距离为顶点i到顶点j的权值；

如果i和j不相邻，则map[i][j]=∞。

如果i==j，则map[i][j]=0;
第2步：以顶点A(假设是第1个顶点)为中介点，若a[i][j] > a[i][1]+a[1][j]，则设置a[i][j]=a[i][1]+a[1][j]。

F. Floyd算法是什么

Floyd算法又称为弗洛伊德算法，插点法，是一种用于寻找给定的加权图中顶点间最短路径的算法。
通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。
从图的带权邻接矩阵A=[a(i,j)] n×n开始，递归地进行n次更新，即由矩阵D(0)=A，按一个公式，构造出矩阵D(1)；又用同样地公式由D(1)构造出D(2)；……；最后又用同样的公式由D(n-1)构造出矩阵D(n)。矩阵D(n)的i行j列元素便是i号顶点到j号顶点的最短路径长度，称D(n)为图的距离矩阵，同时还可引入一个后继节点矩阵path来记录两点间的最短路径。
采用的是(松弛技术)，对在i和j之间的所有其他点进行一次松弛。所以时间复杂度为O(n^3); 其状态转移方程如下： map[i,j]:=min{map[i,k]+map[k,j],map[i,j]} map[i,j]表示i到j的最短距离 K是穷举i,j的断点 map[n,n]初值应该为0，或者按照题目意思来做。
当然，如果这条路没有通的话，还必须特殊处理，比如没有map[i,k]这条路

G. floyd算法中输出最短路径序列的C语言代码

void path(int i,int j)
{
int k;
if(P[i][j][i]==FALSE)
printf("There's no path!");
return;
for(k=0;k<n;k++)
if(P[i][j][k]==TRUE)
{
path(i,k);
path(k,j);
break;
}
}
void print(){
int v,w,u,i;
for (v=0;v<n;++v)
{
for (w=0;w<n;++w)
printf(" %d ",D[v][w]);
printf("\n");
}
printf("Please input the tailvex v1 and headvex v2:");
scanf("v1=%d,v2=%d",&v,&w);
path(v,w);
}
以上两段应该对你有用。

H. 【讨论】最短路径弗洛伊德算法的时间复杂度

那么你的意思是说四个循环全部都执行了的哦？否则就不是O(n4)。你看最后一个循环是需要判断进入的，也就是说，那个循环在最内层，本身次数就少，加上排除不合法条件，很少能执行到，根据算法思想，那么应该忽略常数级

I. 弗洛伊德算法如何去记录最短路径经过的每一个结点

用path数组的递归实现打印

例如：打印i,j之间的路径

当path[i][j]的值为k时，分别再去打印i,k和k,j之间的路径

如此递归直至两点间直接有边相连