最小生成树Prim 模板

class Solution {
public:
    int mp[1005][1005] = {0};
    int cost[1005];
    int vis[1005] = {0};
    int sz;
    int prim(){
        int sum = 0;
        vis[0] = 1;
        for(int i = 0; i < sz - 1; i++){
            int _min = INT_MAX, sub_min;    
            //要将n-1个结点加入最小生成树
            for(int j = 1; j < sz; j ++){
                if(vis[j] == 0 && _min > cost[j]){
                    sub_min = j;
                    _min = cost[j];
                }
            }
            vis[sub_min] = 1;
            sum +=cost[sub_min];
            //更新最小生成树到其他节点的距离
            for(int j = 1; j < sz; j++){
                if(vis[j] == 0 && mp[sub_min][j] < cost[j]){
                    cost[j] = mp[sub_min][j];
                }
            }
        }
        return sum;
    }
    int minCostConnectPoints(vector<vector<int>>& points) {
        //初始化
        memset(mp, INT_MAX, sizeof(mp));
        sz = points.size();
        for(int i = 0; i < sz; i++){
            for(int j = i + 1; j < sz; j++){
                mp[i][j] = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1]);
                mp[j][i] = mp[i][j];
            } 
        }
        cost[0] = 0;
        for(int i = 1; i < sz; i++){
            cost[i] = mp[0][i];
        }
        return prim();
    }
};

### Prim算法实现最小生成树的代码模板 以下是基于Prim算法实现最小生成树的经典代码模板,适用于加权无向图: #### 使用邻接矩阵表示图 ```python import sys def prim_mst(graph): n = len(graph) key = [sys.maxsize] * n # 初始化键值数组,用于记录当前最短距离 parent = [-1] * n # 记录父节点,构建最终MST visited = [False] * n # 节点访问状态 # 初始设置第一个顶点为起点 key[0] = 0 result_edges = [] # 存储MST中的边 for _ in range(n): # 遍历所有顶点 u = min_key(key, visited) # 找到未访问且key值最小的顶点 visited[u] = True # 将该顶点标记为已访问 # 更新相邻顶点的距离 for v in range(n): if graph[u][v] > 0 and not visited[v] and graph[u][v] < key[v]: key[v] = graph[u][v] parent[v] = u # 构建并返回MST的结果 for i in range(1, n): result_edges.append((parent[i], i, graph[parent[i]][i])) return result_edges def min_key(key, visited): """辅助函数:找到未访问过的具有最小key值的顶点""" min_val = sys.maxsize min_index = -1 for v in range(len(key)): if key[v] < min_val and not visited[v]: min_val = key[v] min_index = v return min_index ``` 上述代码实现了通过邻接矩阵存储图结构的方式计算最小生成树。其中`graph`是一个二维列表,代表图的邻接矩阵。 --- #### 使用优先队列优化(适合稀疏图) 对于较大的稀疏图,可以采用堆来加速选取最小权重的过程。下面是使用`heapq`模块实现的版本: ```python import heapq def prim_heap(graph): n = len(graph) visited = set() # 已经加入MST的节点集合 heap = [(0, 0)] # (权重, 起始节点),初始设为从第0个节点出发 total_weight = 0 # MST总权重 mst_edges = [] # 存储MST中的边 while heap: weight, u = heapq.heappop(heap) # 取出当前最小权重的边 if u in visited: # 如果已经访问过,则跳过 continue visited.add(u) # 加入已访问集合 total_weight += weight # 增加权重至总和 # 添加新边到结果集中 if len(mst_edges) != 0: # 排除起始节点的情况 last_edge = mst_edges[-1] if last_edge[1] == u or last_edge[2] == u: mst_edges.append(last_edge) # 对于u的所有邻居,更新候选边 for v, w in enumerate(graph[u]): if w > 0 and v not in visited: # 权重有效且未访问 heapq.heappush(heap, (w, v)) return mst_edges, total_weight ``` 此方法利用了优先队列减少每次查找最小权重的时间复杂度,特别适合处理大规模稀疏图[^2]。 --- ### 总结 以上两种方式分别展示了如何通过朴素版和优化版的Prim算法解决最小生成树问题。前者时间复杂度较高,但易于理解;后者则更高效,尤其针对大型数据集表现优异。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值