最短路径---Dijkstra/Floyd算法

1.Dijkstra算法基础：

         算法过程比prim算法稍微多一点步骤，但思想确实巧妙也是贪心，目的是求某个源点到目的点的最短距离，总的来说dijkstra也就是求某个源点到目的点的最短路，求解的过程也就是求源点到整个图的最短，次短距，第三短距离等（这些距离都是源点到某个点的最短距离）。。。求出的每个距离都对应一个点，也就是要到的到这个点，求的也就是原点到所有点的最短距离，并存在二维数组中，给出目的点就能直接通过查表获得最短距离。

        第1步：以源点START(假设s1)为始点，求最短距离，如何求? 与这个源点相邻的点与源点的距离全部放在一个数组dist[]中，如不可达，dist[]中为最大值，是一维数组原因是默认的是从源点到这个一维数组下标的值，只需目的点作为下标就可，这时从源点到其他点的最短的“1”条路径有了，只要选出dist[]最小的就行（得到最短路径的另一端点假设s2）。

        第2步：这时要寻找源点(设s1)到另外点的次短距离，按路径长度递增次序产生各顶点最短路径，这个距离是dist[]里的值或是从第1步中选择的那个最短距离+从找到点(设s2)出发到其他点的距离（其实这里是一个更新操作更新的是dist[]里的值），如最短距离+从这点（设s2）到其他点的距离小于dist[]里面的值，就可更新dist[]数组，然后再从dist[]中选值最小的，也就是第“2”短路径（次短路径）。

       第3步：寻找第“3”短路径，同上，第二短路径的端点（s3）更新与之相邻其他的点的dist[]数组里面的值。

       第4步：重复上述过程n - 1次（n节点个数），得出结果，其实把源点到所有点的最短路径求出来了，都填在了dist[]表中，要找源点到哪个点的最短路，就只需要查表了。

在未选点集中选择一个最短距离最小的未选点k来扩充已选集是Dijkstra算法的关键。时间复杂度O(n^2).

void Init_Dijkstra(void)
{
    count=0;
    for(int i=0;i<MG->n;i++)
    {
        vis[i]=0;  //状态置0,表示没有求出最短路径
        min_wg[i]=MG->edge[START][i];
        
        if(min_wg[i] == INF)
            min_from[i]=-1;  //表示到顶点i路径最短的上一个顶点不存在
        else
            min_from[i]=START;
    }

    vis[START]=1;
    count++;
    min_wg[START]=0;  //从源点到达源点的边权值为0
    min_from[START]=START;  //源点的父节点为本身
}

void Dijkstra(void)
{
    int min,to_index;
    int new_dis;  //距离更新中间值
    
    while(count < MG->n)
    {
        min=INF;
        to_index=-1;
        for(int i=0;i<MG->n;i++)
            if(!vis[i] && (min_wg[i] < min))
            {
                min=min_wg[i];
                to_index=i;
            }

        if(to_index != -1)
        {    
//            if(to_index == ENDN)  //用于[2]
//                break;
            vis[to_index]=1;
            count++;
        }
        else
            break;

        for(int j=0;j<MG->n;j++)
            if(!vis[j] && MG->edge[to_index][j] < INF)
            {
                new_dis=min_wg[to_index]+MG->edge[to_index][j];
                if(new_dis < min_wg[j])
                {
                    min_wg[j]=new_dis;
                    min_from[j]=to_index;
                }
            }
    }
}

//查找from->to的路径
void SearchPath(int from,int to)
{
    int tot=0;
    int index_temp;  //缓存索引

    path[tot++]=to;
    index_temp=min_from[to];
    while(index_temp != from)  //回溯找到源点 
    {
        path[tot++]=index_temp;
        index_temp=min_from[index_temp];
    }
    path[tot]=from;

    printf("%c",MG->vertex[from]);
    for(int i=tot-1;i>=0;i--)  //对辅助数组进行逆向输出 
        printf("->%c",MG->vertex[path[i]]);
    printf("
");
}

 2.Floyd算法

        Floyd算法用于求最短路径，经典的动态规划，或是有多个起点和多个终点，是解决任意两点间最短路径的一种算法，可正确处理有向图或边负的最短路径问题，但不许有包含带负权的边组成的回路。Floyd算法可以说Warshall算法的扩展，三个for循环解决问题，时间复杂度为O(n^3)。Floyd算法的基本思想：从任意节点A到任意点B的最短路径不外乎2种可能：1是直接从A到B，2是从A经过若干个节点X到B。所以我们设Dis(AB)为节点A到B最短路径距离，对于每一个点X，我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如成立，证明从A到X再到B的路径比A直接到B的路径短，便Dis(AB) = Dis(AX) + Dis(XB)，这样当我们遍历完所有节点X，Dis(AB)中记录的便是A到B的最短路径距离。

      接下来如何找出最短路径？需借助辅助数组Path：同时借助[栈或队列或数组]。path[i][j] =k表示最短路径i-…j 和j的直接前驱为k，此时初始化是path[i][j]=i，即是：i-->......-->k ->j举例：如1-> 5->4  4->3->6 ，此时path[1][6]=0；0表示1->6不通。当我们引入节点k = 4此时有1->5->4->3->6，显然有paht[1][6] = 3 = paht[4][6] =paht[k][6]，如是有 path[i][j] =path[k][j] 。对于1->5相邻边，我们可以在初始化时候 有 paht[1][5]=1;如是对于最短路径1->5->4->3->6有paht[1][6] = 3; paht[1][3]= 4;paht[1][4] = 5; paht[1][5] =1 如此逆推不难得到最短路径记录值。

void Init_Floyd(void)
{
    for(int i=0;i<MG->n;i++)
        for(int j=0;j<MG->n;j++)
        {
            if(i == j)
            {
                dis[i][i]=0;
                path[i][i]=i;
            }
            else
            {
                dis[i][j]=MG->edge[i][j];
                if(dis[i][j] == INF)
                    path[i][j]=-1;
                else
                    path[i][j]=i;  //记录j的前驱节点
            }
        }
}
void Floyd(void)
{
    int i,j,k;

    for(k=0;k<MG->n;k++)
    {
        for(i=0;i<MG->n;i++)
            for(j=0;j<MG->n;j++)
                if((dis[i][k]>0 && dis[i][k]<INF) &&   //防止加法溢出 
                      (dis[k][j]>0 && dis[k][j]<INF) &&
                        dis[i][k] +dis[k][j] < dis[i][j])
                {
                    dis[i][j]=dis[i][k] +dis[k][j];
                    path[i][j]=path[k][j];  //记录j的直接前驱k
                }
    }
}

// 路径查询
void SearchPath(int from,int to)
{
    int min_path[MAXL],tot=0;
    int index_temp; //缓存索引

    min_path[tot++]=to;
    index_temp=path[from][to];
    while(index_temp != from)  //回溯找到源点
    {
        min_path[tot++]=index_temp;
        index_temp=path[from][index_temp];
    }
    min_path[tot]=from;

    printf("%c",MG->vertex[from]);  //对辅助数组进行逆向输出
    for(int i=tot-1;i>=0;i--)
        printf("->%c",MG->vertex[min_path[i]]);
}