数据结构复习---最短路径

求解图中的最短路径算法有：Dijkstra算法和Floyd算法。

Dijkstra算法：

求带权有向图中某个源点到其余各顶点的最短路径，最常用的是Dijkstra算法。该算法设置一个集合S，记录已求得的最短路径的顶点，初始时把源点V0放入S中。此外，在构造过程中还设置了两个辅助数组：

dist[]:记录了从源点V0到其他个顶点当前的最短路径长度。

path[]：path[i]表示了从源点到顶点i之间的最短路径的前驱结点，在算法结束前，可根据其值追溯得到源点V0到顶点Vi的最短路径。

1）初始化：集合S初始为{0}，dist[]的初始值为dist[i]=arcs[0][i]，i=1,2,3,……

2）从顶点集合V-S中选出Vj，满足dist[j]=Min{dist[i] }，Vj就是当前求得的一条从V0出发的最短路径的终点，令S=S+{j}；

3）修改从V0出发到集合V-S上任一顶点Vk可达的最短路径长度。如果：dist[i]>dist[j]+arcs[j][i]；则令dist[i]=dist[j]+arcs[j][i];

4）重复2）~3）操作工n-1，直到所有的顶点都包含在S中。

#define INF 10000
int d[INF][INF];
int dist[INF];
int path[INF];

void Dijkstra(int v,int n)
{
    bool visit[n];
    menset(visit,false,sizeof(visit));
    for(int i=0;i<n;i++)
    dist[i]=d[v][i];
    visit[v]=true;
    for(int i=0;i<n-1;i++)
    {
        int temp = INF;
        int k=0;
        for(int j=0;j<n;j++)
        {
            if(dist[j]<temp&&(!visit[j]))
            {
                    temp=dist[j];
                    k=j;
            }
        }
        path[i]=k;
        visit[k]=true;
        for(int j=0;j<n;j++)
        {
            if(disk[j]>dist[k]+d[k][j])
            disk[j]=disk[k]+d[k][j];
        }
    }
}

Dijkstra算法不允许边上带有负权值。

Floyd算法：从0~n，已结点i为中间结点，例如计算V0到Vj的距离，已Vi为中间结点。 if a[0][j]>a[0][i]+a[i][j] then a[0][j]=a[0][i]+a[i][j]

void Floyd(MGrapg G)
{
    int A[MAXN][MAXN];
    int path[MAXN][MAXN];
    int n = G.n;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            a[i][j]=G.edges[i][j];
            path[i][j]=-1;
        }
    }
    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(a[i][j]>(a[i][k]+a[k][j]))
                {
                    a[i][j]==a[i][k]+a[k][j];
                    path[i][j]=k;
                }
            }
        }
    }
}