Kruskal、Prim

稠密用Prim，稀疏用Kruskal

1.Kruskal

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。
1. 把图中的所有边按代价从小到大排序；
2. 把图中的n个顶点看成独立的n棵树组成的森林；
3. 按权值从小到大选择边，所选的边连接的两个顶点ui,vi,应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。
4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

struct Edge{
    int from, to, w;
    Edge(int x, int y, int z): from(x), to(y), w(z){}
    bool operator < (const Edge &rhs) const{
        return w > rhs.w;
    }
};
int parent[1005];
priority_queue<Edge> q;
queue<Edge> q_res;
void make_set(int x){parent[x]=x;}
int findset(int x){return parent[x] != x ? parent[x] = findset(parent[x]) : x;}
void unionset(int x, int y){
    if(x < y)
        parent[y] = x;
    else
        parent[x] = y;
}
void kruskal(){
    for(int i = 1; i <= N; i++)
        make_set(i);
    while(!q.empty()){
        Edge tmp = q.top(); q.pop();
        int x = findset(tmp.from);
        int y = findset(tmp.to);
        if(x != y){
            if(res < tmp.w)
                res = tmp.w;
            unionset(x, y);
            q_res.push(tmp);
        }
    }
}
void init(){
    while(!q.empty())
        q.pop();
    while(!q_res.empty())
        q_res.pop();
}
int main(){
    while(scanf("%d%d", &N, &M) != EOF){
        init();
        res = -1;
        int a, b, wt;
        for(i = 0; i < M; i++){
            scanf("%d%d%d", &a, &b, &wt);
            q.push(Edge(a, b, wt));
        }
        kruskal();
        printf("%d\n", res);
        printf("%d\n", q_res.size());
        while(!q_res.empty()){
            Edge tmp = q_res.front(); q_res.pop();
            printf("%d %d\n", tmp.from, tmp.to);
        }
    }
    return 0;
}

2.Prim

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

图的所有顶点集合为V；初始令集合u={s},v=V−u;
在两个集合u,v能够组成的边中，选择一条代价最小的边(u0,v0)，加入到最小生成树中，并把v0并入到集合u中。
重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。

由于不断向集合u中加点，所以最小代价边必须同步更新；需要建立一个辅助数组closedge,用来维护集合v中每个顶点与集合u中最小代价边信息，：

#define INF 0x3f3f3f3f
#define VNUM  1e5 + 5
 
struct Node{
    int v,next,w;
    bool operator < (const Node &a) const{
        return w > a.w;
    }
} p[N],t1,t2;
 
int dis[N], vis[N], head[N], cnt;
int res;
 
void addedge(int u,int v,int w){
    p[cnt].v = v;
    p[cnt].next = head[u];
    p[cnt].w = w;
    head[u] = cnt++;
}
 
void prim(){
    priority_queue<Node> q;
    for(int i = head[0] ; i != -1 ; i = p[i].next){
        int v = p[i].v;
        if(p[i].w < dis[v]){
            dis[v] = p[i].w;
            t1.w = dis[v];
            t1.v =  v;
            q.push(t1);
        }
    }
    vis[0] = 1;
    while(!q.empty()){
        t1 = q.top();
        q.pop();
        int u = t1.v;
        if(vis[u]) continue;
        vis[u] = 1;
        res += dis[u];
        for(int i = head[u]; i != -1; i = p[i].next){
            int v = p[i].v;
            if(!vis[v] && dis[v] > p[i].w){
                dis[v] = p[i].w;
                t2.v = v;
                t2.w = dis[v];
                q.push(t2);
            }
        }
    }
}
 
int main(){
    int n, m, w;
    while(scanf("%d", &n), n){
        memset(p, 0, sizeof(p));
        memset(head, -1, sizeof(head));
        memset(vis, 0, sizeof(vis));
        char u, v;
        for(int i = 0; i < n - 1; i++){
            cin >> u >> m;
            for(int j = 0; j < m; j++){
                cin >> v >> w;
                addedge(u, v, w);
                addedge(v, u, w);
            }
        }
        for(int i = 0; i < n; i++) dis[i] = INF;
        res = 0;
        prim();
        printf("%d\n", res);
    }
    return 0;
}

稠密用Prim，稀疏用Kruskal

猜你喜欢