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

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

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

int main()
{
    int n,m,i,j,k,min,t1,t2,t3;
    int e[7][7],dis[7],book[7] = {0};
    int inf = 99999999;
    int count = 0,sum = 0;
    cin >> n >> m;
    
    //初始化 用邻接矩阵存储 
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
            if(i == j)
                e[i][j] = 0;
            else
                e[i][j] = inf;
    
    //读入边 无向图来回都得设置权值 
    for(int i = 1;i <= m;i++)
    {
        cin >> t1 >> t2 >> t3;
        e[t1][t2] = t3;
        e[t2][t1] = t3;
    }
    
    //初始化dis数组，这里是第一个顶点到各个顶点的初始距离，因为当前生成树中只有一个顶点
    for(int i = 1;i <= n;i++)
        dis[i] = e[1][i];
        
    //Prime核心部分
    //将第一个顶点（即1号顶点）加入生成树
    book[1] = 1;//这里用book数组来标记一个顶点是否已经加入生成树 
    count++;//表示生成树中已加入一个顶点 
    while(count < n)
    {
        min = inf;
        
        //扫描找出距离当前根顶点相连接的最小权值的顶点 
        for(int i = 1;i <= n;i++)
        {
            if(book[i] == 0 && min > dis[i])//如果根节点未被标记并且根节点到剩下的n-1个顶点之间有直连线（就是相连着的边） 
            {
                min = dis[i];//就将这条边的权值代替之前初始化时的无穷大 ，更新min的值，min的值更新只在此for循环中有效，此for循环目的是找出连接根节点权值最小的那个顶点j，再把min放入for循环中，一直比较，直至找到最小的权值及连的顶点j 
                j = i;//同时将此时的顶点的编号记录在临时变量j中，以便接下来使用 
            }
        }
        book[j] = 1;//将上面for循环中找到的最小权值的顶点j加入到生成树中并标记 
        count++;//生成树中的顶点加一 
        sum += dis[j];//将权值最小的边都累加，最终得到最优解 
        
        //扫描当前顶点j所有的边，再以j为中心点，更新生成树到每一个非树顶点的距离 
        for(k = 1;k <= n;k++)
        {
            if(book[k] == 0 && dis[k] > e[j][k])//e[k]表示第一个加入的根顶点到顶点k之间的权值（可能直接连接也可能间接连接），e[j][k]表示的是当前根顶点作为j，到与j顶点直接相连的顶点k的权值 
                dis[k] = e[j][k];//此循环的目的是找出离j顶点最近的顶点 
        }
    }
    cout << sum;
    return 0;
}
/*
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[10];//为了方便排序，这里创建了一个结构体数组来存储边的关系，数组大小根据实际情况来设置，要比m的最大值大1 
int n,m;
int f[7],sum = 0,countt = 0;//并查集需要用到的一些变量,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 1;
    }
    return 0;
}

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

int main()
{
    //读入顶点个数n和边的条数m 
    cin >> n >> m;
    //读入边，这里用结构体数组来存储边的关系 
    for(int i = 1;i <= m;i++)
        cin >> e[i].u >> e[i].v >> e[i].w;
//    quicksort(1,m);//按照权值从大到小对边进行快速排序
    //快速排序权值 
    sort(e + 1,e + m + 1,cmp);
    //并查集初始化
    for(int i = 1;i <= n;i++)
        f[i] = i;
    
    //Kruskal算法核心部分
    for(int i = 1;i <= m;i++)
    {
        //判断一条边的两个顶点是否已经连通，即判断是否已在同一个集合中 
        if(merge(e[i].u,e[i].v))//如果目前不连通，则选用这条边 
        {
            countt++;//满足条件将顶点加入生成树 
            sum += e[i].w;//路径累加和 
        }
        if(countt == n - 1)//当顶点均加入到生成树中时，结束循环 
            break;
    }
    cout << sum << endl;
    return 0;
}

运行结果：

 并查集例题

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

//并查集的使用 
#include<iostream>
using namespace std;
int f[1000],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 = 1;i <= n;i++)
        f[i] = i;
    for(int i = 1;i <= m;i++)
    {
        cin >> x >> y;
        merge(x,y);//将两个顶点传入合并集合函数中进行操作 
    }
    for(int i = 1;i <= n;i++)
    {
        if(f[i] == i)//根节点的值依旧是原先的值，即判断有几个顶点的值不变即有几个不同的集合 
            sum++;
    }
    cout << sum << endl;
    return 0;
}
/*
10 9
1 2
3 4
5 2
4 6
2 6
8 7
9 7
1 6
2 4
3
*/

运行结果：

✌