图的相关算法

一、最小生成树 (Prim与Kruskal)

1.最小生成树的性质

       设 N=（V,{E}）是一个连通图，U是V的非空子集，若(u,v)是满足u，且v∈V-U的具有最小权值的边,则必存在一棵包含(u,v)的最小生成树。

2.最小生成树的概念

   ① 生成树:连通图的极小连通子图称为图的生成树,显然顶点数为n 的连通图, 生成树边数为n-1。
   ②从连通图中某一顶点出发遍历图时,图中所有的顶点加上遍历时经过的边所构成的子图T, 恰好就是一棵生成树。
   ③最小生成树：生成树各边权值之和为生成树代价，其代价最小的生成树为最小生成树。
   ④最小生成树有两种算法:普利姆(Prim)算法&克鲁斯卡尔(Kruskal)算法。

Prim算法（加边法）

    1.基本思路： 在所有已连通的点中，寻找由这些点组成的边中权值最小的边，并且这个边可以连接一个新的点(还未连通)。那么这个的边就是最小生成树的一部分，将这个新的点标记为已连通。重复上述过程，直到所有点均连通。也就是从一个初始点出发，根据这个点延伸的边，每次连通一个点。直到把所有点全部连通。

   2.实现代码：使用邻接矩阵存储的图  //lowcost[i]=w；adjvex[i]=k。表示顶点Vi和顶点Vk之间的权值为w。

void prime(MGraph G){
    for(int i=1;i<G.vertexNu;i++){
        lowcost[i]=G.arc[0][i];  adjvex[i]=0;
    }
    lowcost[0]=0;
    for(i=1;i<G.vertexNum;i+++){
        k=MinEdge(lowcost,G.vertexNum)
        cout<<K<<adjvex[k]<<lowcost[k];
        lowcost[k]=0;
    }
    for(j=1;j<G.vertexNum;j++){
        if((G.arc[k][j]<lowcost[j]){
              lowcost[j]=G.arc[k][j];
              arcvex[j]=k;
           }
    }
}

Kruskal算法（加边）

   1.基本思路：将所有边按照权值从小到大排序，然后依次从小到大，将还没有加入的点的边纳入最小生成树中，为使生成树边的权值之和达到最小,则尽可能地选取权值小的边作为生成树中的边。

 

二、最短路径(Dijkstra与Floyd)

 求一个顶点到另外一个点之间的最短路径。

 

Dijkstra算法：

    1.基本思想：按路径长度递增的次序产生最短路径的算法

   如果源点v0到顶点vi的弧是v0到各点(最短)路径集合中最短者，则一定可以确定的是< v0,vi>是源点v0到vi的最短路径。

• 第一条最短路径(vo到vi是所有点中路径最短)最短路径的特点:这条路径上，必定只含有一条弧，并且这条弧权值最小。
• 下一条(路径次短)的最短路径的特点:它只含有两种情况：或者直接从源点到改点vj，或者从源点到vi，在到达vj
• 再下一条长度次短的特点:它可能有两种情况：或者直接从源点到达改点，或者从源点到达vi/cj,然后到达该点
• 其余最短路径的的特点:它或者是直接从源点到该点(只含一条弧)； 或者是从源点经过已求得最短路径的顶点，再到达该点

2.代码准备：

• 数组dist[n]：每个分量dist[i]表示当前所找到的从始点v到终点vi的最短路径的长度。初态为：     若从v到vi有弧，则dist[i]为弧上权值；否则置dist[i]为∞。
• 数组path[n]：path[i]是一个字符串，表示当前所找到的从始点v到终点vi的最短路径。初态为：若从v到vi有弧，则path[i]为vvi；否则置path[i]空串。
• 数组s[n]：存放源点和已经找到最短路径的终点，其初态为只有一个源点v。

3.代码实现：

const int MAX=1000;
void  Dijkstra(MGraph g, int v){
    for (int i =0; i<g.vexnum ; i++){
        dist[i]=g.arcs[v][i];
            if ( dist[i]!= MAX)
                path [i]=g.vertex[v]+g.vertex[i];
            else
                path[i]="";
    }
       S[0]=g.vertex[v];
        num=1;
    while (num<g.vextexNum)
    {   k=0;
        for(i=0;i<G.vertexNum;i++)
           if((dist[i]<dist[k])
               k=i
        cout<<dist[k]<<path[k];
        s[num++]=G.vertex[k];
        for(i=0;i<G.vertexNum;i++){
            if(dist[k]+g.arc[k][i]<dist[i] {
                dist[i]=dist[k]+g.arc[k][i];
                path[i]=path[k]+g.vertex[i];
            }
        }
}

Floyd算法（暴力）：

1.从vi到vj的所有可能存在的路径中，选出一条长度最短的路径。

2.代码准备:(邻接矩阵存储带权图)

• 数组dist[n][n]：存放在迭代过程中求得的最短路径长度。
• 数组path[n][n]：     存放从vi到vj的最短路径，初始为path[i][j]="Vi-Vj"

3.代码实现：

void Floyd(MGraph G)
{
    for (int i=0; i<G.vertexNum; i++)
       for (int j=0; j<G.vertexNum; j++)
       {
          dist[i][j]=G.arc[i][j];
          if (dist[i][j]!=10000)
               path[i][j]=G.vertex[i]+G.vertex[j];
          else path[i][j]="";
       }
    for (k=0; k<G.vertexNum; k++)
        for (i=0; i<G.vertexNum; i++)
           for (j=0; j<G.vertexNum; j++)
               if (dist[i][k]+dist[k][j]<dist[i][j]) {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j]=path[i][k]+path[k][j];
              }
}