最小生成树算法（Prim和Kruskal[并查集板子]）

---

最小生成树算法

最小生成树算法

Prim算法

算法核心

算法的核心在于加点法

• 从所有已连的点的邻边的权值中选能到未到点的最小权值边进行连接

算法过程

算法代码

const int INF=99999;
const int MAX_V=100;    //最大节点数
int cost[MAX_V][MAX_V]; //cost[u][v]表示边e=(u,v)的权值，不存在时为INF
int mincost[MAX_V]; //记录当前已连接结点集合（U）到未连接结点集合（U-V）的最小权值
bool used[MAX_V];   //记录点是否在已连接集合（U）中
int V;  //顶点数

int prim()
{
    for(int i=0;i<V;i++){
        mincost[i]=INF;
        used[i]=false;
    }
    mincost[0]=0;
    int res=0;
    
    while(true){
        int v=-1;
        for(int i=0;i<V;i++)
            if(!used[i]&&(v==-1||mincost[i]<mincost[v]))    v=i;
        
        if(v==-1) break;
        used[v]=true;
        res+=mincost[v];
        for(int i=0;i<V;i++)
            mincost[i]=min(mincost[i],cost[v][i]);  //每次加入新结点都更新一次最短权值表
    }
    
    return res;
}

算法分析

算法的时间复杂度为O(|V|₂)
如果算法使用堆进行优化，算法时间复杂度可缩减为O(|E|*log|V|)

Kruskal算法

算法核心

算法的核心在于加边法

• 将所有的边以非递减的序列进行排序
• 从非递减的序列中，每次顺序选择一条不会与图中已连边产生环的边进行相连
• 并查集的应用

算法过程

算法代码

并查集

int par[MAX_V]; //父亲
int height[MAX_V];    //树的高度

//初始化n个元素
void init(int n)    //n为结点数
{
    for(int i=0;i<n;i++){
        par[i]=i;
        height[i]=0;
    }
}

//查找树的根
int find(int x)
{
    if(par[x]==x)   return x;
    else    return par[x]=find(par[x]);
}

//合并x和y所属的结点
void unite(int x, int y)
{
    x=find(x);
    y=find(y);
    if(x==y)    return;
    
    if(height[x]<height[y])
        par[x]=y;
    else{
        par[y]=x;
        if(height[x]==height[y])
            height[x]++;
    }
}

//判断x和y是否属于一个集合
bool same(int x, int y)
{
    return find(x)==find(y);
}

简化并查集

int f[MAX_V]; //父亲

//查找树的根
int find(int x)
{
    if(f[x]==x)   return x;
    else    return f[x]=find(f[x]);
}

//合并x和y所属的结点
void merge(int x, int y)
{
  int t1=find(x);
  int t2=find(y);

  if(x!=y)
    f[t1]=t2;
}

//其他的操作基于这两个函数进行

Kruskal算法

const int MAX_E=10000;  //边的最大数
const int MAX_V=10000;  //顶点的最大数
struct edge
{
    int u,v,cost;
}es[MAX_E];
int V,E;    //顶点数和边数

int par[MAX_V]; //父亲
int height[MAX_V];    //树的高度

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

//省略并查集的函数
//......

int kruskal()
{
    sort(es,es+E,cmp);
    init(V);
    int res=0;
    
    for(int i=0;i<E;i++){
        edge e=es[i];
        if(!same(e.u, e.v)){
            unite(e.u, e.v);
            res += e.cost;
        }
    }
    
    return res;
}

算法分析

Kruskal算法在边的排序上最费时间，因此算法时间复杂度为O(|E|*log|V|)