数据结构课设——校园导航系统第二天

弗洛伊德算法——求权值最短路线

（一）算法思想：

Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点 i 到点 j 的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）。

从任意节点 i 到任意节点 j 的最短路径不外乎2种可能，一是直接从i到j，二是从i经过若干个节点k到 j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离。

（二）算法过程

1）首先把初始化距离dist数组为图的邻接矩阵，路径数组path初始化为-1。其中对于邻接矩阵中的数首先初始化为正无穷，如果两个顶点存在边则初始化为权重 　　

2）对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是就更新它。

状态转移方程为

如果 dist[i][k]+dist[k][j] < dist[i][j]

则dist[i][j] = dist[i][k]+dist[k][j]

 

 

Dijikstra算法

 

Dijikstra算法主要是针对有权图的最短路径问题提出的，且具体问题中不能出现权值为负的边，即负值圈问题，

对于Dijikstra算法的理解，首先得从最短路径的最优子结构说起。（这部分引用海子的博客园的Dijkstra算法（单源最短路径）一文的说法）

 

最短路径的最优子结构性质

该性质描述为：如果P(i,j)={Vi…Vk…Vs…Vj}是从顶点i到j的最短路径，k和s是这条路径上的一个中间顶点，那么P(k,s)必定是从k到s的最短路径。下面证明该性质的正确性。

 

假设P(i,j)={Vi…Vk…Vs…Vj}是从顶点i到j的最短路径，则有P(i,j)=P(i,k)+P(k,s)+P(s,j)。而P(k,s)不是从k到s的最短距离，那么必定存在另一条从k到s的最短路径P(k,s)，那么P(i,j)=P(i,k)+P(k,s)+P(s,j)<P(i,j)。则与P(i,j)是从i到j的最短路径相矛盾。因此该性质得证。

 

那么Dijikstra算法描述如下：

假设存在G=<V,E>，源顶点为V0，U={V0},dist[i]记录V0到i的最短距离，path[i]记录从V0到i路径上的i前面的一个顶点。

1）从V-U中选择使dist[i]值最小的顶点i，将i加入到U中；

2）更新与i直接相邻顶点的dist值。dist[j]=min{dist[j],dist[i]+matrix[i][j]}

3）直到U=V，算法停止。

起始Dijikstra算法的本质就是贪心算法。

//14.查询两景点间的最短路径（floyd算法）
void floyd(mgraph c)//一种暴力破解获取最短路径的算法 
{    int i,j,k;
    for(i=1;i<=key;i++)//将图的邻接矩阵赋值给 shortest二维数组，将矩阵pathh全部初始化为-1 
    {    for(j=1;j<=key;j++)
        {    shortest[i][j]=c.arcs[i][j].adj;
            pathh[i][j]=j; 
        }
    }
    /*int i1,j1,k1=0;
    for(i1=1;i1<=key;i1++)
        printf("%6d",i1);//横着的标号1到11
    printf("\n");
    for(i1=1;i1<=key;i1++)
    {  printf("%d",i1);//竖着的标号1到11
      for(j1=1;j1<=key;j1++)
      {    
         printf("%6d",pathh[i1][j1]);
          k1++;
          if(k1%key==0) printf("\n");
      }        
    }
    printf("\n\n\n");*/ 
    
    for(k=1;k<=key;k++)//核心操作，完成了以k为中间点对所有的顶点对（i,j）进行检测和修改 
    {    for(i=1;i<=key;i++)
        {    for(j=1;j<=key;j++)
             {
                 if(shortest[i][j]>shortest[i][k]+shortest[k][j])
                 {    shortest[i][j]=shortest[i][k]+shortest[k][j];                     
                      pathh[i][j]=pathh[i][k];//记录一下所走的路 //P数组用来存放前驱顶点  
                }
             }
        }
    }
}
/*void printf_Pshuzu() //输出前驱矩阵
{    int i,j,k=0;
    for(i=1;i<=key;i++)
        printf("%6d",i);//横着的标号0到11
    printf("\n");
    for(i=1;i<=key;i++)
    {  printf("%d",i);//竖着的标号0到11
      for(j=1;j<=key;j++)
      {    printf("%6d",pathh[i][j]);
          k++;
          if(k%key==0) printf("\n");
      }        
    }
    printf("\n\n\n");
}*/

 

//打印出最短路径
void display(mgraph c, int i, int j)
{
    int a, b;
    a = i;
    b = j;
    printf("您要查询的两景点间最短路径：\n\n");
    printf("%d%s", a, c.vexs[a].name);
    while (pathh[i][j] != b)
    {
        printf("-->%d%s", pathh[i][j], c.vexs[pathh[i][j]].name);
        i = pathh[i][j];
    }
    printf("-->%d%s\n\n", b, c.vexs[b].name);
    printf("%s-->%s的最短路径是：%d 米。\n\n", c.vexs[a].name, c.vexs[b].name, shortest[a][b]);
}
//任意两点间最短距离（弗洛伊德算法）
int shortdistance(mgraph c)
{
    int i, j;
    printf("请输入要查询的两个景点的数字编号（1->11）中间用空格间隔开。\n");
    scanf("%d %d", &i, &j);
    if (i > key || i < 0 || j > key || j < 0)
    {
        printf("输入信息错误！\n\n");
        printf("请输入要查询的两个景点的数字编号（1->11）中间用空格间隔开。\n");
        scanf("%d %d", &i, &j);
    }
    else
    {
        floyd(c); //printf_Pshuzu();
        display(c, i, j);
    }
    return 1;
}

//用迪杰斯特拉算法，求出一个景点到其他景点间的最短路径，
void shortestpath_dij(mgraph c)
{
    int v0, v, w, k = 1, min, t, p;
    int final[MaxVertexNum];          //final[w]=1表示已经求得顶点V0到Vw的最短路径
    int Patharc[MaxVertexNum];        //用于存储最短路径下标的数组
    int ShortPathtable[MaxVertexNum]; //用于存储到各点最短路径的权值和
    printf("\n请输入一个起始景点的编号：");
    scanf("%d", &v0);
    printf("\n\n");
    while (v0 < 0 || v0 > key)
    {
        printf("\n您输入的景点编号不存在\n");
        printf("请重新输入：");
        scanf("%d", &v0);
    }
    //初始化数据
    for (v = 1; v <= c.vexnum; v++) //数组0还是空出来
    {
        final[v] = 0;                          //全部顶点初始化为未找到最短路径
        ShortPathtable[v] = c.arcs[v0][v].adj; //将与v0点有连线的顶点加上权值
        Patharc[v] = 0;                        //初始化路径数组p为0
    }
    ShortPathtable[v0] = 0; // V0至v0的路径为0
    final[v0] = 1;          //V0至v0不需要路径
    //开始主循环，每次求得V0到某个v顶点的 最短路径
    for (v = 1; v <= c.vexnum; v++)
    {
        min = Infinity;
        for (w = 1; w <= c.vexnum; w++) //找出最近的顶点和权值
        {
            if (!final[w] && ShortPathtable[w] < min) //有边
            {
                k = w;
                min = ShortPathtable[w];
            }
        }
        final[k] = 1; //将目前找到的最近的顶点置1
                      //修正当前最短路径及距离
        for (w = 1; w <= c.vexnum; w++)
        { //如果经过v顶点的路径比现在这条路径的长度短的话，更新
            if (!final[w] && (min + c.arcs[k][w].adj < ShortPathtable[w]))
            {
                ShortPathtable[w] = min + c.arcs[k][w].adj; //修改当前路径长度
                Patharc[w] = k;                             //存放前驱结点（像糖葫芦）
            }
        }
    }

    /*//打印P数组
     printf("打印P数组:");
     for(t=1;t<=c.vexnum;t++)
     {
         printf("%d ",Patharc[t]);
     }
     printf("\n\n");
     //打印s数组
     printf("打印S数组:");
     for(t=1;t<=c.vexnum;t++)
     {
         printf("%d ",ShortPathtable[t]);
     }
     printf("\n\n");*/

    //打印最短路径
    for (t = 1; t <= c.vexnum; t++)
    {
        p = t;
        if (t != v0) //反向输出
        {
            printf("%d%s", t, c.vexs[t].name);
            for (w = 1; w <= c.vexnum; w++)
            {
                if (Patharc[p] != 0)
                {
                    printf("<--%d%s", Patharc[p], c.vexs[p].name);
                    p = Patharc[p];
                }
            }
            printf("<--%d%s", v0, c.vexs[v0].name);
            printf("\n总路线长为%d米\n\n", ShortPathtable[t]);
        }
    }
}