prim算法堆优化

#include<stdio.h>  
#include<string.h>  
#include<algorithm>  
#include<queue>  
#include<iostream>  
using namespace std;  
  
int n;  
int head[3010];  
  
struct node{  
    int to;  
    int c;  
    int next;  
}edge[200000];  
  
struct ver{  
    int x;  
    int dis;  
    bool operator < (const ver& t) const{  
        return dis>t.dis;  
    }  
};  
  
priority_queue<ver> q;  
  
int  prime()  
{  
    int res = 0;  
    //init a collection  
    int dis[3010];  
    int v_j;  
    int vis[3010];  
    for(int i = 0; i<n; i++) {  
        dis[i] = 0x3f3f3f;  
    }  
   // q.push(0);  
    vis[0] = 1;  
    for(int i = head[0]; i!= -1; i = edge[i].next) {  
        v_j = edge[i].to;  
        dis[v_j] = edge[i].c;  
        q.push(ver{v_j,dis[v_j]});  
    }  
    dis[0] = 0x3f3f3f;  
    for(int i = 1; i<n; i++) {  
        int temp_j = 0;  
        int min_c = 0x3f3f3f;  
        //找出dis中的最小值的坐标,这里体现log n  
        ver t_ver = q.top();  
        q.pop();  
        temp_j = t_ver.x;  
        res += t_ver.dis;  
        vis[temp_j] = 1;  
        for(int j = head[temp_j]; j!=-1; j = edge[j].next) {  
            v_j = edge[j].to;  
            if(!vis[v_j] && dis[v_j] > edge[j].c) {  
                dis[v_j] = edge[j].c;  
                q.push(ver{v_j,dis[v_j]});  
            }  
        }  
    }  
    return res;  
}  
  
init() {  
    for(int i = 0;i<n;i++) {  
        head[i] = -1 ;  
    }  
}  
  
int main()  
{  
    int m;  
    while(~scanf("%d%d",&n,&m)) {  
        init();  
        int u,v,c;  
        int k = 0;  
        for(int i = 0;i<m;i++) {  
            scanf("%d%d%d",&u,&v,&c);  
            edge[k].next = head[u];  
            edge[k].to = v;  
            edge[k].c = c;  
            head[u] = k;  
            k++;  
            edge[k].next = head[v];  
            edge[k].to = u;  
            edge[k].c = c;  
            head[v] = k;  
            k++;  
        }  
        cout<<prime()<<endl;  
    }  
} 

### 经过优化Prim算法实现与原理 #### 1. Prim算法的核心思想 Prim算法是一种用于求解图中的最小生成树(Minimum Spanning Tree, MST)的经典贪心算法。该算法从任意一个顶点开始构建一棵树,在每一步中都会选择当前未加入到树中的边权值最小的一条边,直到所有的顶点都被纳入这棵树为止[^1]。 #### 2. 优化的意义 原始版本的Prim算法通常会使用邻接矩阵来存储图的信息,并通过遍历整个数组寻找下一个距离最近的节点。然而这种方法的时间复杂度较高,为 \(O(V^2)\),其中 \(V\) 是顶点的数量。当引入优先队列(即结构)作为辅助数据结构时,可以显著降低时间复杂度至 \(O((E+V) \log V)\)[^4] 或者更具体地说是 \(O(E \log V)\),这里 \(E\) 表示边数。 #### 3. 优化后的Prim算法工作流程 在优化Prim算法里,利用一个小根维护候选集合内的各结点及其对应的最短路径长度(Key值)。初始状态下设定源点\(s\) 的 Key=0 并将其余所有其他节点初始化成无穷大表示尚未访问状态;随后不断取出顶元素(即当前离已知部分最近的那个新顶点u), 更新与其相邻但还未处理过的那些邻居v们的key如果发现经由u到达它们能获得更优解的话就调整这些邻居们的状态并重新插入回当中去完成动态更新过程直至最终形成完整的MST[^5]。 以下是基于Python语言的一个简单实现例子: ```python import heapq def prim_heap(graph, start_vertex): visited = set() min_heap = [(0, start_vertex)] total_weight = 0 while min_heap: weight, u = heapq.heappop(min_heap) if u in visited: continue visited.add(u) total_weight += weight for v, w in graph[u]: if v not in visited and (w < float('inf')): heapq.heappush(min_heap, (w, v)) return total_weight ``` 在这个代码片段中`graph`应该是一个字典形式表达出来的加权无向图,键代表各个顶点而值则是一系列元组列表表明相连另一端以及相应权重[(vertex_to, edge_weight)...]; `start_vertex`指定起始探索位置. #### 4. 总结对比Kruskal算法 相较于另一种常用的解决相同问题的方法——克鲁斯卡尔(Kruskal)算法来说,普利姆更适合于稠密图场景下操作因为后者每次都需要对全局范围内全部可能存在的连接关系做一次排序耗时较长达到O(|E|*log|E|); 而前者借助局部最优策略配合高效的数据管理工具可以在稀疏条件下取得更好的性能表现.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值