精华内容
下载资源
问答
  • Prim最小生成树Prim最小生成树Prim最小生成
  • 最小生成树prim算法

    2010-09-18 17:26:44
    最小生成树prim最小生成树prim最小生成树prim最小生成树prim
  • prim生成模板

    2018-12-19 17:25:42
    O(v^2)的复杂度,求次小生成的时候,prim貌似是最好的选择。 krukstra不需要考虑重边的问题,但是prim要考虑。 #include <bits/stdc++.h> using namespace std; #define inf 0x3f3f3f3f #define ...

     算法思路挺简单的,之前的prim都是用了邻接表+优先队列,但是这个最初的写法还是挺有用的。O(v^2)的复杂度,求次小生成树的时候,prim貌似是最好的选择。

    krukstra不需要考虑重边的问题,但是prim要考虑。

    #include <bits/stdc++.h>
    using namespace std;
    #define inf 0x3f3f3f3f
    #define res register int
    const int maxn=5005;
    int low[maxn];//记录每一个未遍历的点到已经在生成树上点的最短距离。 
    int dis[maxn][maxn];//记录距离 
    int N,M;
    int vis[maxn];
    
    int prim()
    {
    	int ans=0;
    	for(res i=1;i<=N;i++)
    	 	low[i]=dis[1][i]; 
    	vis[1]=1;
    	for(res i=1;i<N;i++){
    		int minc=inf;
    		int c=-1;
    		for(res j=1;j<=N;j++){
    			if(!vis[j]&&low[j]<minc){
    				minc=low[j];
    				c=j;
    			}
    		}
    		if(inf==minc) return -1;
    		ans+=minc;
    		vis[c]=1;
    		for(res j=1;j<=N;j++)
    			if(!vis[j]&&low[j]>dis[c][j])
    				low[j]=dis[c][j];
    	}
    	return ans;
    }	
    
    int main()
    {
    	scanf("%d%d",&N,&M);
    	memset(dis,inf,sizeof(dis));
    	for(res i=0;i<=N;i++)
    		dis[i][i]=0;
    	int a,b,c;
    	for(res i=0;i<M;i++){
    		scanf("%d%d%d",&a,&b,&c);
    		if(c<dis[a][b])
    			dis[a][b]=dis[b][a]=c;//去重边
    	}
    	int ans=p();
    	if(-1!=ans) printf("%d",ans);
    	else printf("orz");
    	return 0;
    }
    

     

    展开全文
  • Prim最小生成

    2018-11-16 16:21:17
    Prim最小生成是一个动态的过程, 并不是一次性把所有结点的最小的key都算出来然后一个一个往最小生成里面加, 而是先选定一个结点,让他最小成为第一个加进去,以此为基础开始循环,更新key的值, 每次都加入...

    Prim最小生成树是一个动态的过程,
    并不是一次性把所有结点的最小的key都算出来然后一个一个往最小生成树里面加,
    而是先选定一个结点,让他最小成为第一个加进去,以此为基础开始循环,更新key的值,
    每次都加入当前最小的并且没有被加入的,每一次循环都在更新,直到把所有的都加进去。

    代码几乎是抄的,因为我没有写出来…
    修改了一些,加了些注释,让输出清楚完整一些,改的有点不像C++了…
    修改前的源码是这位博主的:https://blog.csdn.net/I_am_a_winer/article/details/45276643

    贴下新的代码:

    
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<queue>
    #define INF 0x7fffffff
    
    using namespace std;
    
    int Map[110][110], dis[110], vis[110];      
    //map就是存两点权值的矩阵,注意:二维数组的下标刚好是两个结点的值。dis相当于书上的key,是不断更新的当前结点相连的边的最小权重,vis记录结点是否已经被访问
    int N, M;
    
    void prime(int s) {
    	printf("路径\n");
    
    	memset(vis, 0, sizeof(vis));                 //初始化访问的数组都为0
    
    	for (int i = 1; i <= N; i++)            //每个结点的权值都初始化为与1的之间边的权值
    		
    		dis[i] = Map[1][i];                //权值可以理解成距离,似乎更好理解
    
    	int sum = 0;
    	
    	vis[s] = s;                        
    	
    	printf("%d    ", s);
    
    	for (int p = 1; p <= N - 1; p++) {  //进行N-1次循环,加入剩下的N-1个点
    		
    		int t, Min = INF;
    
    		for (int i = 1; i <= N; i++)
    
    			if (!vis[i] && dis[i]<Min)              //如果没有访问过这个结点并且他的值小于min //寻找集合1-S中到集合S最近的点t
    	        
    				Min = dis[i], t = i;                //最小值就变成他并且记录他的下标i
    		
    		sum += Min; vis[t] = 1;         //找到那个当前的最小值之后,把标记他为已经访问,然后再把权值加到路径里面去
    	
    		printf("%d   ", t);
    		
    		for (int i = 1; i <= N; i++) 
    			
    			if (!vis[i] && dis[i]>Map[t][i])      //更新与t相连且在1-S中的点到集合S的距离
    			
    				dis[i] = Map[t][i];
    	}
    	printf("\n最小生成树权值:\n");
    
    	cout << sum << endl;
    }
    
    
    int main() {
    	int s;
    	//freopen("D:\\in.txt","r",stdin);
    	printf("输入结点个数:\n");
    
    	while (cin >> N && N) {
    
    		for (int i = 0; i <= N; i++)              //初始化矩阵为最大值
    			for (int j = 0; j <= N; j++) 
    				Map[i][j] = INF;
    
    		printf("输入边的条数:\n");
    		scanf_s("%d", &M);
    
    		printf("输入第一个点:\n");
    		scanf_s("%d", &s);
    	
    		//	M = (N - 1)*N / 2;
    		
    		printf("输入两点和权重(逗号分隔)\n");
    		
    		int a, b, c;
    		for (int i = 0; i<M; i++) {
    			scanf_s("%d,%d,%d", &a, &b, &c);
    			Map[a][b] = Map[b][a] = c;                         //注意无向图在给矩阵赋值的时候是双向的
    		}
    		prime(s);
    	}
    	return 0;
    }
    
    

    在这里插入图片描述

    测试数据来自算法导论,是没有问题的。把abc改成123这样的。
    在这里插入图片描述

    展开全文
  • Prim算法 最小生成

    2018-03-08 22:07:44
    普里姆算法(Prim算法),图论中的一种算法,可在加权连通图里搜索最小生成。意即由此算法搜索到的边子集所构成的中,不但包括了连通图里的所有顶点(英语:Vertex (graph theory)),且其所有边的权值之和亦为...
  • 最小生成 Prim算法

    2016-12-20 21:05:16
    最小生成prim算法
  • prim最小生成

    2019-04-22 17:14:00
    prim每次会找出尽量小的那个边,将其加入到中,最终使得生成长大。 中有n-1个节点时或者剩下的所有边都是INF,算法结束。 (如果剩下的所有边都是INF, 那么最小生成不存在)。 我们这里使用邻接矩阵来...

    prim和DIjkstra相似,都使用了贪心策略,加一些限制条件。

    prim每次会找出尽量小的那个边,将其加入到树中,最终使得生成树长大。

    树中有n-1个节点时或者剩下的所有边都是INF,算法结束。

    (如果剩下的所有边都是INF, 那么最小生成树不存在)。

     

    我们这里使用邻接矩阵来实现prim算法。

     

    初始化:

      定义dist[]数组,保存每个节点到树的最小距离,当节点在树中时更新为0。

      先找到一个根节点A,将其加入树中, dist[A] = 0

    (1)从还没加入到树中的节点中选择一条到树距离最短的i,将其加入树中:

        dist[i] = 0

    (2)节点 i 加入树可能导致其他节点到树的最短距离改变,所以我们对与 i 节点相连的并且不在树中的节点最短距离进行更新

        如果G[i][j] < dist[j]

          dist[j] = G[i][j]

    (3)循环直到找出了n-1条边或者剩下的边中都是INF,算法结束。

    typedef int Vertex;
    
    typedef int Weight;
    
    typedef struct MyGraph
    {
        int v, e;
        Weight g[MaxVertexNum][MaxVertexNum];
    }MyGraph;
    
    void Prim(MyGraph& G, Vertex u)
    {
        int dist[G.v];
        
        //初始化 
        for(int i = 0; i < G.v; i++)
        {
            if(G.g[u][i] == -1)
                dist[i] = INF;
            else
                dist[i] = G.g[u][i];
        }
        
        int count = 1;
        for(; count < G.v; count++)
        {
            int mmin = INF;
            int k = -1;
            //找到最小距离 
            for(int i = 0; i < G.v; i++)
            {
                if(dist[i] != 0 && mmin > dist[i])
                {
                    mmin = dist[i];
                    k = i;
                }
            }
            //若找不到则代表不能得到生成树 
            if(k == -1)
                return false;
                
            //将最小节点加入
            dist[k] = 0; 
            count++;
            //更新dist数组
            for(int i = 0; i < G.v; i++)
            {
                if(dist[i] != 0 && dist[i] > G.g[k][i])
                    dist[i] = G.g[k][i];
            }
        }
        
    }

     

    转载于:https://www.cnblogs.com/yangzixiong/p/10751320.html

    展开全文
  • 最小生成prim

    2016-01-03 10:15:03
    最小生成prim
  • 最小生成Prim算法

    2016-09-05 16:23:03
    最小生成Prim算法
  • prim生成课程设计报告,这是我做课设时用的程序,报告内容很详细,希望对大家有帮助!
  • prim 最小生成

    2021-06-05 18:06:28
    在图论中,叫做求最小生成prim 算法采用的是一种贪心的策略。 每次将离连通部分的最近的点和点对应的边加入的连通部分,连通部分逐渐扩大,最后将整个图连通起来,并且边长之和最小。 不断迭代 用dist[j] = min...
    算法原理

    给定一个无向图,在图中选择若干条边把图的所有节点连起来。要求边长之和最小。在图论中,叫做求最小生成树。

    prim 算法采用的是一种贪心的策略。

    每次将离连通部分的最近的点和点对应的边加入的连通部分,连通部分逐渐扩大,最后将整个图连通起来,并且边长之和最小。

    不断迭代 dist[j] = min(dist[j], g[t][j])更新到集合的最短距离。

    优化

    prim算法与dijikstra算法一样都可以用堆优化的方式实现对稀疏图的优化,但是稀疏图一般不用prim(Kruskal真香)

    与dijkstra的联系

    Dijkstra算法是更新到起始点的距离,Prim是更新到集合S的距离

    #difine INF 0x3f3f3f3f
    int n;      // n表示点数
    int g[N][N];        // 邻接矩阵,存储所有边
    int dist[N];        // 存储其他点到当前最小生成树的距离
    bool st[N];     // 存储每个点是否已经在生成树中
    
    
    // 如果图不连通,则返回INF, 否则返回最小生成树的树边权重之和
    int prim()
    {
        memset(dist, 0x3f, sizeof dist);
    
        int res = 0;
        for (int i = 0; i < n; i ++ )
        {
            int t = -1;
            for (int j = 1; j <= n; j ++ )
                if (!st[j] && (t == -1 || dist[t] > dist[j]))
                    t = j;
    
            if (i && dist[t] == INF) return INF;
    
            if (i) res += dist[t];
            st[t] = true;
    
            for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
        }
    
        return res;
    }
    
    展开全文
  • 最小生成树Prim算法理解

    万次阅读 多人点赞 2014-08-16 18:49:34
    MST(Minimum Spanning Tree,最小生成
  • 本代码利用c#语言,实现了基于Prim算法实现最小生成的可视化界面。用户可以自己输入点以及边的权值,计算出最小生成
  • 最小生成 Prim

    2018-05-21 22:29:48
    void Prim(Graph t) //Prim  //把节点划分为两个集合,标记集合和未标记集合 //维持一个记录表,里面是所有未标记集合到已标记集合的边的相应最小权重,lowerCost //每次从记录表中选取从小的权重,把此边的未标...
  • matlab小白 最小生成 在tree中添加路径利用prim算法直接导出最小生成
  • prim算法prim算法prim算法prim算法prim算法prim算法prim算法prim算法prim算法
  • 最小生成树prim

    2015-10-08 19:15:36
    prim
  • prim用c++实现的最小生成的源码,easy to understand!
  • Prim最小生成算法

    2015-05-25 15:59:16
    刷题遇到一道Prim最小生成算法的实现的题目,重新温习一下最小生成算法
  • 最小生成——prim

    2016-09-07 14:10:45
    最小生成——prim
  • prim最小生成算法

    2017-09-12 16:04:28
    * prim,最小生成算法,适用于点少边多的情况 * 最小生成:能够连通所有点的边权值的最小和 * @author Administrator * */ /** * * @author Administrator * */ public class Prim {
  • 最小生成树Prim算法

    2011-06-15 13:45:35
    关于图的最小生成Prim算法的实现,包含流程图和关键代码!
  • Prim算法求最小生成

    千次阅读 2018-12-30 16:11:02
    Prim算法求最小生成 ——HM 我来肤浅介绍一下Prim算法求最小生成的方法。若有不知道最...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,484
精华内容 12,593
关键字:

prim树