数据结构——最小生成树

最小生成树

‘　　对于一个图连通图G<V,E>，n个点，e条边，最小生成树就是n-1条边图的生成子图，且这n-1条边的权值和最小。
对于一个图的两种算法：prim算法和kruskal算法，这两种算法都是基于贪心思想的。

一、prim算法（增点法）

伪代码实现：
辅助变量：lowcost数组，保存当前可连通的其他节点的最小权值。cnt=0表示当前树连接节点的个数(或者可以保存边的个数，n-1条时即树生成完毕)。
1）找一个顶点，作为第一个新节点 cnt++
2）更新lowcost数组，并将新节点lowcost置零。
3）在lowcost数组中寻找到 未连接的其他节点权值最小的的点，作为新节点（增点 cnt++）。如果cnt！=n，当前节点返回步骤2）。

实现

例题链接

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

class Graph
{
private:
    int e,n,a[500][500];

public:
    Graph(){}
    Graph(int e,int n):e(e),n(n){
        for(int i=1;i<=e;i++){
            for(int j=1;j<=e;j++){
                cin>>a[i][j];
            }
        }
    }
    void prim();
};
void Graph::prim(){
    int lowcost[e+1],cnt=0;
    lowcost[1]=0;
    for(int i=2;i<=e;i++) lowcost[i]=a[1][i];
    while(cnt!=e-1){
        int tmp,minn=100;
        for(int i=1;i<=e;i++){
            if(lowcost[i]!=0&&lowcost[i]<minn){
                    tmp=i;
                    minn=lowcost[i];
            }
        }
        cout<<minn<<" ";
        cnt++;
        lowcost[tmp]=0;
        for(int i=1;i<=e;i++){
            lowcost[i]=min(a[tmp][i],lowcost[i]);
        }
    }
}
int main()
{
    int e,n;
    cin>>e>>n;
    Graph ob=Graph(e,n);
    ob.prim();
}

总结：prim算法主要适用于图是用邻接矩阵来存储时。复杂度O（n*n）

二、kruskal算法（增边法）

思想：一开始将所有点分离,即删除所有的边，通过增加边来构成树。
伪代码实现：
辅助需要：并查集，判断两点是否连通，决定是否增加两点之间的边，最终实现所有点连通。
1）将所有的边按权值进行排序
2）从权值大到小进行遍历边，对于一条边，如果两端点所在的连通块不连通，增加该条边。
例题链接

模板实现

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
int parent[200001];
struct Node
{
    int x,y;
    int data;
    bool operator <(Node B)const{
        return data<B.data;
    }
}a[200001];

int getr(int x){
    if(x==parent[x]) return x;
    return parent[x]=getr(parent[x]);
}

int main()
{
    int e,n,cnt=0,ans=0;
    cin>>e>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i].x>>a[i].y>>a[i].data;
    }
    for(int i=1;i<=n;i++) parent[i]=i;
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++){
        int x=a[i].x,y=a[i].y;
        int p1=getr(x),p2=getr(y);
        if(p1!=p2){
            cnt++;
            parent[p1]=p2;
            ans+=a[i].data;
        }
    }
    if(cnt<e-1){
        cout<<"orz"<<endl;
    }
    else cout<<ans<<endl;
}

总结：kruskal 算法由于递归实现寻找根的同时将路径压缩，极大地降低了复杂度。总的复杂度只有mlog（m）.