最小生成树prim模板

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

const int INF = 0x3f3f3f3f;
int vis[2000], dis[2000], graph[2000][2000];	//vis标记  dis其实抽象为边的集合  graph[a][b]从a到b长度 
int n, m; 
 
int prime()
{
    int index;
    int sum = 0;
    vis[1] = 1;
    for(int i = 1; i <= n; i++){	//prim的思想是通过不断将最短的边纳入一个集合完成,对于变而言是基于点的基础的,所以随便默认一个初始点通过对电的操作完成对边的操作 
        dis[i] = graph[1][i];		//这里是1号点与所有点的距离    
    }
    
    for(int i = 1; i < n; i++){		//因为n个点之间只有n-1条边所以 循环纳入集合的次数为n-1 而不是<=n 
        
        int min = INF;
        for(int j = 1; j <= n; j++){	//这里是以一个点为根节点或者以一个前驱集合为基础找到一条与之最短的边标记然后对所带点操作完成功能 
            if(!vis[j] && dis[j] < min){
                min = dis[j];
                index = j;    
            }    
        }
        
        vis[index] = 1;
        sum += min;
        
        for(int j = 1; j <= n; j ++){		
            if(!vis[j] && dis[j] > graph[index][j]){	//这里的dis是上一个集合或者点与除了刚纳入集合边所带的点的距离,这里很厉害 dis[j] > graph[index][j] 之前所纳入集合的边所带的点与剩下的点之间的距离大还是之前集合离剩下的点距离大(很强可以画图便于理解) 
                dis[j] = graph[index][j];
            }    
        }    
    } 
    return sum;    
} 

void init()
{
	memset(vis, 0, sizeof(vis));
	memset(dis, 0, sizeof(dis));
	for(int i = 0; i <= n; i++){
		for(int j = 0; j <= n; j++){
			graph[i][j] = INF;
			graph[i][i] = 0;
		}
	}
	return ;
}

int main()
{
	
	while(scanf("%d", &n) != EOF && n){
		scanf("%d", &m);
		init();
		int a, b, len;
		int len_min = INF;
		for(int j = 1; j <= m; j++){
			scanf("%d%d%d", &a, &b, &len);
			if(graph[a][b] > len){
				graph[a][b] = len;
				graph[b][a] = len;	//这里注意双向边那么有可能 a->b的len不等于b->a的len 
			}
		}
		
		cout << prime() << endl;
	}
	return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

const int INF = 0x3f3f3f3f;
int vis[2000], dis[2000], graph[2000][2000];	
int n, m; 
 
int prime()
{
    int index;
    int sum = 0;
    vis[1] = 1;
    for(int i = 1; i <= n; i++){	
    
    for(int i = 1; i < n; i++){		
        
        int min = INF;
        for(int j = 1; j <= n; j++){	
            if(!vis[j] && dis[j] < min){
                min = dis[j];
                index = j;    
            }    
        }
        
        vis[index] = 1;
        sum += min;
        
        for(int j = 1; j <= n; j ++){		
            if(!vis[j] && dis[j] > graph[index][j]){	 
                dis[j] = graph[index][j];
            }    
        }    
    } 
    return sum;    
} 

void init()
{
	memset(vis, 0, sizeof(vis));
	memset(dis, 0, sizeof(dis));
	for(int i = 0; i <= n; i++){
		for(int j = 0; j <= n; j++){
			graph[i][j] = INF;
			graph[i][i] = 0;
		}
	}
	return ;
}

int main()
{
	
	
	return 0;
}

### 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算法解决最小生成树问题。前者时间复杂度较高,但易于理解;后者则更高效,尤其针对大型数据集表现优异。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值