最小生成树（MST）Kruskal算法 + hdu三道例题

#最小生成树 （MST）

标签（空格分隔）： 算法思想

---

在无向图中，连通且不含 圈 的图称为树。 给定无向图G = （V,E），连接G中所有点，且边集是E的子集的树称
为G的生成树，而权值最小的生成树称为最小生成树（MST）
常见算法： Kruskal 算法 和 Prim 算法。

圈指的是任选一个顶点为起点，沿着不重复的边，经过不重复的顶点为途径，之后又回到起点的闭合途径称为圈。(可以类似理解成欧拉回路，那就要求奇数度的点为0）

Kruskal 算法

Kruskal 算法第一步是给所有边按照从小到大的顺序进行排列（可以用algorithm 自带的sort)。
接下来从小到大考察每条边(u,v)。

情况1： u和v在同一个连通分量**（连通分量的概念）**，那么加入(u,v)之后会形成环，因此不能选择。
情况2： 如果u和v在不同的连通分量(也可以想成是树)，那么加入(v,v)之后一定是最优的。

伪代码:
    把所有边排序，记第i小的边为e[i] (i<=i<m)
    初始化MST为空
    初始化连通分量，让每一个点自成一个独立的连通分量
    for( int i = 0; i < m; i++){
        if(e[i].u和e[i].v不在同一个连通分量）{
            把边e[i]加入MST
            合并e[i].u和e[i].v所在的连通分量
        }
    }

/*
最小生成树(MST) Krustal算法
伪代码:
    把所有边排序，记第i小的边为e[i] (i<=i
int pre[MAX]; // 并查集
int FindRoot(int x)
{
    /*
    迭代写法
    */
    int ans = x;
    while( pre[ans]!=ans ){
        ans = pre[ans];
    }
    pre[x] = ans; //路径压缩
    return ans; //返回根节点
    /*
    递归写法
    return p[x] == x? x : FindRoot(p[x]); //这个没有压缩路径吧？
    */
}
void InitTree(int totalnode)
{
    for(int i=0;i<=totalnode;i++){
        pre[i] = i;
    }
}
struct Edge
{
    int x; //节点x
    int y; //节点y
    int cost; //权重（花费，距离等）
    bool operator < (const Edge & e){
        return cost < e.cost;
    }
}edge[MAX];
int Kruskal(int cnt,int totalnode) //cnt 代表总边数
{
    //采用结构体的方法实现
    int totalcost = 0;
    int totaledge = 0;
    sort(edge,edge+cnt); //根据权重从小到大排序
    for(int i=0;i<cnt;i++){
        int fx = FindRoot(edge[i].x);
        int fy = FindRoot(edge[i].y);
        if(fx!=fy){ //两个节点不在同一个连通分量上
            pre[fy] = fx; //把两个节点相连
            totaledge++;
            totalcost+=edge[i].cost;
        }
    }
    if(totaledge+1!=totalnode) //这里的n代表节点数
        cout<<" No answer ! "<<endl;
    else cout<<"MSTcost:"<<totalcost<<endl;
    return 0;
}

例题：
hdu-1233 还是畅通工程

#include 
#include 
using namespace std;
const int MAX = 1e5+5;
struct Node{
    int x;
    int y;
    int length;
    bool operator < (const Node & h){
        return length<h.length;
    }
}node[MAX];
int pre[MAX];
int Find(int x)
{
    int ans = x;
    while(pre[ans]!=ans){
        ans = pre[ans];
    }
    pre[x] = ans;
    return ans;
}
int main()
{
    int n;
    while(cin>>n && n){
        int m = n*(n-1)/2;
        int x,y,l;
        for(int i=0;i<=n;i++){
            pre[i] = i;
        }
        for(int i=0;i<m;i++){
            cin>>x>>y>>l;
            node[i] = {x,y,l};
        }
        sort(node,node+m);
        // 最小生成树
        int total=0;
        int totalcost=0;
        while(total<n-1){
            for(int i=0;i<m;i++){ //在所有的边里从小到大找一条
                int fx = Find(node[i].x);
                int fy = Find(node[i].y);
                if(fx!=fy){
                    pre[fy]=fx;
                    total++;
                    totalcost += node[i].length;
                }
            }
        }
        cout<<totalcost<<endl;
    }
    return 0;
}

hdu-1875 畅通工程再续

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAX = 1e5+5;
struct Node
{
    int x;
    int y;
    double length;
    bool operator < (const Node & h){
        return length<h.length;
    }
}node[MAX];
struct Island
{
    int x;
    int y;
}island[MAX];
vector <int> vec[MAX];
int pre[MAX];
int Find(int x)
{
    int ans = x;
    while(pre[ans]!=ans){
        ans = pre[ans];
    }
    pre[x] = ans;
    return ans;
}
double func(int x1,int x2,int y1,int y2)
{
    return sqrt(pow(x1-x2,2)+pow(y1-y2,2));
}
bool vis[MAX];
int main()
{
    int T;
    cin>>T;
    while(T--){
        int n;
        cin>>n; //小岛个数
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++){
            pre[i] = i;
        }
        int x,y;
        for(int i=1;i<=n;i++){
            cin>>x>>y;
            island[i] = Island{x,y};
        }
        int cnt=0;
        int tot=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i==j)
                    continue;
                double l = func(island[i].x,island[j].x,island[i].y,island[j].y);
                if(l>=10 && l<=1000){ //这两个点可以相连啊
                    node[cnt++] = Node{i,j,l};
                }
            }
        }
        sort(node,node+cnt);
        // 最小生成树
        int total=0;
        double totalcost=0;
        for(int i=0;i<cnt;i++){ //在所有的边里从小到大找一条
            int fx = Find(node[i].x);
            int fy = Find(node[i].y);
            if(fx!=fy){
                pre[fy]=fx;
                total++;
                totalcost += node[i].length;
            }

        }
        if(total!=n-1){
            cout<<"oh!"<<endl;
            continue;
        }
        cout<<fixed<<setprecision(1);
        cout<<totalcost*100<<endl;
    }
    return 0;
}

hdu-1301

#include 
#include 
using namespace std;
const int MAX =1e5+5;
struct Node
{
    int x;
    int y;
    int length;
    bool operator < (const Node & h)
    {
        return length<h.length;
    }
}road[MAX];
int pre[MAX];
int Find(int x)
{
    int ans =x;
    while(pre[ans]!=ans)
        ans = pre[ans];
    pre[x] =ans;
    return ans;
}
int main()
{
    int n; // 代表村庄数
    while(cin >> n && n){
        char viliage;
        int k;
        for(int i=0;i<=n;i++){
            pre[i] = i;
        }
        int cnt=0; //记录边数
        for(int i=0;i<n-1;i++){ //字母用相应的数字来表示即可
            cin>>viliage>>k;
            char ch;
            int l;
            for(int i=0;i<k;i++){
                cin>>ch>>l;
                road[cnt++] = Node{ viliage-'A'+1, ch-'A'+1,l}; //把所有的路都记录下来
            }
        }
        sort(road,road+cnt);
        int totalcost=0;
        int tot=0;
        for(int i=0;i<cnt;i++){
            int fx = Find(road[i].x);
            int fy = Find(road[i].y);
            if(fx!=fy){
                pre[fy]=fx;
                totalcost+=road[i].length;
                tot++;
            }
        }
       // cout<
        if(tot==n-1)
            cout<<totalcost<<endl;;
    }
    return 0;
}