最小生成树Kruskal算法

HDU 1301

题意：题干给出原先的图，其中有n个点，给出n-1个点的关系，问连接所有点之后最小路径和

并查集+结构体排序

Kruskal算法

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define ll long long int
struct zuobiao
{
    int u,v,len;
}a[121212];
int f[100];
int cmp(zuobiao a,zuobiao b)
{
    return a.len<b.len;
}
int find(int a)
{
    int r=a;
    while(f[r]!=r)
    r=f[r];
    int i=a;
    int j;
    while(i!=r)
    {
        j=f[i];
        f[i]=r;
        i=j;
    }
    return r;
}
void merge(int a,int b)
{
    int A,B;
    A=find(a);
    B=find(b);
    if(A!=B)
    f[B]=A;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        if(n==0)break;
        for(int i=0;i<n;i++)
        {
            f[i]=i;
        }
        int cont=0;
        for(int i=0;i<n-1;i++)
        {
            char uu[3];
            char vv[3];
            scanf("%s",uu);
            int k;
            scanf("%d",&k);
            for(int j=0;j<k;j++)
            {
                int dis;
                scanf("%s%d",vv,&dis);
                a[cont].u=uu[0]-'A';
                a[cont].v=vv[0]-'A';
                a[cont].len=dis;
                cont++;
            }
        }
        ll output=0;
        sort(a,a+cont,cmp);
        for(int i=0;i<cont;i++)
        {
            if(find(a[i].u)!=find(a[i].v))
            {
                output+=a[i].len;
                merge(a[i].u,a[i].v);
            }
        }
        printf("%I64d\n",output);
    }
}

转自：https://blog.csdn.net/mapoos/article/details/79551885

Kruskal算法

用途

处理最小生成树(MST)问题，即在给定的图中求树，使得这棵树拥有图中所有顶点，且所有边都是图中已知的边，且满足整棵树的边权之和最小。适用于边少的稀疏图。

算法描述

总体思路为：每次找到当前图中未被选中的边权最小的边，如果边的两个顶点不在同一个连通块中，那么就把该边加入到最小生成树集合中。具体步骤如下：

1. 创建并维护一个并查集，用于判断结点所属连通块；
2. 对图中所有边按边权从小到大排序；
3. 依次选择每条边，判断边的顶点是否属于同一连通块，如果否则将该边加入到最小生成树中，如果是则不作处理；
4. 重复步骤3直到处理完所有边，或是最小生成树中的边数已经达到 n - 1；
5. 判断最小生成树中的边数，如果小于 n - 1，说明图不连通，无解。

代码实现

const int maxn = 1000;

struct edge
{
    int u, v;       // 边顶点
    int cost;       // 边权
};

edge E[maxn];       // 边数组
int n, m;           // 结点数，边数
int father[maxn];   // 并查集数组

bool cmp(edge a, edge b)        
{
    return a.cost < b.cost;     // 按照边权从小到大排序
}

int findRoot(int x)             // 寻找根节点并压缩路径
{
    if (x == father[x])
        return x;

    int root = findRoot(father[x]);
    father[x] == root;
    return root;
}

int Kruskal()
{
    int sum = 0, numEdge = 0;       // 记录边权和，最小生成树边数

    for (int i = 0; i < n; i++)     // 初始化并查集数组
        father[i] = i;
    sort(E, E + m, cmp);            // 边排序

    for (int i = 0; i < m; i++)
    {
        int rootU = findRoot(E[i].u);
        int rootV = findRoot(E[i].v);
        if (rootU != rootV)         // 顶点属于不同连通块，则将边加入树
        {
            father[rootU] = rootV;
            sum += E[i].cost;
            numEdge++;
            if (numEdge == n - 1)   // 边数达到 n - 1 退出
                break;
        }
    }

    if (numEdge < n - 1)           // 边数小于 n - 1，说明图不连通，无解
        return - 1;

    return sum;                     // 返回边权和
}