最小生成树两个经典算法（Prime算法、Kruskal算法） - biaobiao88

经典的最小生成树例子，Prime算法，具体的步骤及其注释本人均在代码中附加，请仔细阅读与品味，要求，可以熟练的打出。

 //Prime算法基础
 #include<iostream>
 using namespace std;

 int main()
 {
     int n,m,i,j,k,min,t1,t2,t3;
     int e[][],dis[],book[] = {};
     int inf = ;
     int count = ,sum = ;
     cin >> n >> m;

     //初始化 用邻接矩阵存储
     for(int i = ;i <= n;i++)
         for(int j = ;j <= n;j++)
             if(i == j)
                 e[i][j] = ;
             else
                 e[i][j] = inf;

     //读入边 无向图来回都得设置权值
     for(int i = ;i <= m;i++)
     {
         cin >> t1 >> t2 >> t3;
         e[t1][t2] = t3;
         e[t2][t1] = t3;
     }

     //初始化dis数组，这里是第一个顶点到各个顶点的初始距离，因为当前生成树中只有一个顶点
     for(int i = ;i <= n;i++)
         dis[i] = e[][i];

     //Prime核心部分
     //将第一个顶点（即1号顶点）加入生成树
     book[] = ;//这里用book数组来标记一个顶点是否已经加入生成树
     count++;//表示生成树中已加入一个顶点
     while(count < n)
     {
         min = inf;

         //扫描找出距离当前根顶点相连接的最小权值的顶点
         for(int i = ;i <= n;i++)
         {
             if(book[i] ==  && min > dis[i])//如果根节点未被标记并且根节点到剩下的n-1个顶点之间有直连线（就是相连着的边）
             {
                 min = dis[i];//就将这条边的权值代替之前初始化时的无穷大 ，更新min的值，min的值更新只在此for循环中有效，此for循环目的是找出连接根节点权值最小的那个顶点j，再把min放入for循环中，一直比较，直至找到最小的权值及连的顶点j
                 j = i;//同时将此时的顶点的编号记录在临时变量j中，以便接下来使用
             }
         }
         book[j] = ;//将上面for循环中找到的最小权值的顶点j加入到生成树中并标记
         count++;//生成树中的顶点加一
         sum += dis[j];//将权值最小的边都累加，最终得到最优解 

         //扫描当前顶点j所有的边，再以j为中心点，更新生成树到每一个非树顶点的距离
         for(k = ;k <= n;k++)
         {
             if(book[k] ==  && dis[k] > e[j][k])//e[k]表示第一个加入的根顶点到顶点k之间的权值（可能直接连接也可能间接连接），e[j][k]表示的是当前根顶点作为j，到与j顶点直接相连的顶点k的权值
                 dis[k] = e[j][k];//此循环的目的是找出离j顶点最近的顶点
         }
     }
     cout << sum;
     return ;
 }
 /*
 6 9
 2 4 11
 3 5 13
 4 6 3
 5 6 4
 2 3 6
 4 5 7
 1 2 1
 3 4 9
 1 3 2
 19
 */

运行结果：

Kruskal算法，需要用到并查集，具体请看以下代码

 //Kruskal算法
 #include<iostream>
 #include<algorithm>
 using namespace std;
 struct edge
 {
     int u;
     int v;
     int w;
 }e[];//为了方便排序，这里创建了一个结构体数组来存储边的关系，数组大小根据实际情况来设置，要比m的最大值大1
 int n,m;
 int f[],sum = ,countt = ;//并查集需要用到的一些变量,f数组大小根据实际情况来设置，要比n的最大值大1 

 ////这个也是快速排序，也可以替代sort函数
 //void quicksort(int left,int right)
 //{
 //    int i,j;
 //    struct edge t;
 //    if(left > right)
 //        return;
 //    i = left;
 //    j = right;
 //    while(i != j)
 //    {
 //        //顺序很重要，要先从右边开始找
 //        while(e[j].w >= e[left].w && i < j)
 //            j--;
 //        //再从左边开始找
 //        while(e[i].w <= e[left].w && i < j)
 //            i++;
 //        //交换
 //        if(i < j)
 //        {
 //            t = e[i];
 //            e[i] = e[j];
 //            e[j] = t;
 //        }
 //    }
 //    //最终将基准数归位，将left和i互换
 //    t = e[left];
 //    e[left] = e[i];
 //    e[i] = t;
 //
 //    quicksort(left,i - 1);//继续处理左边的，这里是一个递归的过程
 //    quicksort(i + 1,right);//继续处理右边的，这里是一个递归的过程
 //    return;
 //}

 //并查集寻找祖先的函数
 int getf(int v)
 {
     if(f[v] == v)
         return v;
     else
     {
         //这里是路径压缩
         f[v] = getf(f[v]);
         return f[v];
     }
 }
 //并查集合并两个子集合的函数
 int merge(int v,int u)
 {
     int t1,t2;
     t1 = getf(v);
     t2 = getf(u);
     if(t1 != t2)//判断两个点是否在同一个集合中
     {
         f[t2] = t1;
         return ;
     }
     return ;
 }

 bool cmp(const edge &a,const edge &b)
 {
     return a.w < b.w;
 }

 int main()
 {
     //读入顶点个数n和边的条数m
     cin >> n >> m;
     //读入边，这里用结构体数组来存储边的关系
     for(int i = ;i <= m;i++)
         cin >> e[i].u >> e[i].v >> e[i].w;
 //    quicksort(1,m);//按照权值从大到小对边进行快速排序
     //快速排序权值
     sort(e + ,e + m + ,cmp);
     //并查集初始化
     for(int i = ;i <= n;i++)
         f[i] = i;

     //Kruskal算法核心部分
     for(int i = ;i <= m;i++)
     {
         //判断一条边的两个顶点是否已经连通，即判断是否已在同一个集合中
         if(merge(e[i].u,e[i].v))//如果目前不连通，则选用这条边
         {
             countt++;//满足条件将顶点加入生成树
             sum += e[i].w;//路径累加和
         }
         if(countt == n - )//当顶点均加入到生成树中时，结束循环
             break;
     }
     cout << sum << endl;
     return ;
 }

运行结果：

并查集例题

下面是对并查集使用的代码，并查集不太理解的可以看看下面的代码

 //并查集的使用
 #include<iostream>
 using namespace std;
 int f[],n,m,k,sum;

 //这是找爹的递归函数，不停的去找爹，直到找到祖宗为止，即找到根节点，这个函数的目的是判断两个顶点是否属于同一个集合
 int getf(int v)
 {
     if(f[v] == v)
         return v;
     else
     {
         /*这里是路径压缩，每次在函数返回的时候，顺带把同一个集合里面的元素都改为根节点的祖先编号，这样可以提高今后找到树的祖先的速度*/
         f[v] = getf(f[v]);
         return f[v];
     }
 }
 //这里是合并两子集合的函数,在合并函数中调用getf函数，看两个顶点是否是属于同一个集合，然后再决定是否执行合并操作
 void merge(int v,int u)
 {
     int t1,t2;
     t1 = getf(v);
     t2 = getf(u);
     if(t1 != t2)//根据调用getf的函数，判断两个顶点是否在同一个集合中，即是否为同一个祖先
     {
         f[t2] = t1;
     }
 }

 int main()
 {
     int x,y;
     cin >> n >> m;
     //这里是初始化，非常的重要，数组里面存的是自己数组下标的编号就好了
     for(int i = ;i <= n;i++)
         f[i] = i;
     for(int i = ;i <= m;i++)
     {
         cin >> x >> y;
         merge(x,y);//将两个顶点传入合并集合函数中进行操作
     }
     for(int i = ;i <= n;i++)
     {
         if(f[i] == i)//根节点的值依旧是原先的值，即判断有几个顶点的值不变即有几个不同的集合
             sum++;
     }
     cout << sum << endl;
     return ;
 }
 /*
 10 9
 1 2
 3 4
 5 2
 4 6
 2 6
 8 7
 9 7
 1 6
 2 4
 3
 */

运行结果：

✌