最小生成树 Prime算法 简单题

最新推荐文章于 2022-05-23 16:33:15 发布
最新推荐文章于 2022-05-23 16:33:15 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011699990/article/details/39500719
版权

相比于Kruskal算法，Prime算法是以顶点为主导地位的

将图中所有的点分到两个集合  S和T中去  S中的点表示图中已经已经选择了的点  T中的点表示待选择的点

每次从T中选择到S中的点的距离最小的点加入到S中去

 

prime（）算法中会有三个数组

low[]  存放顶点集合T内各顶点到集合S中 各顶点权值最小的边的权值

nearvex[]  记录集合T内各顶点到集合S中哪个顶点最近   当nearvex[i]为-1时  表示顶点i在集合S中

edge[i][j]表示i到j的权值

 

ZOJ 1586

题意很容易理解  没啥说的 

这个题不需要输出选择的边 所有low[]数组可以与nearvex[]数组的功能合并

代码如下：

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:18px;">
#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>

#define eps 1e-8
#define op operator
#define MOD  10009
#define MAXN  100100
#define INF 0x7fffffff
#define FOR(i,a,b)  for(int i=a;i<=b;i++)
#define FOV(i,a,b)  for(int i=a;i>=b;i--)
#define REP(i,a,b)  for(int i=a;i<b;i++)
#define REV(i,a,b)  for(int i=a-1;i>=b;i--)
#define MEM(a,x)    memset(a,x,sizeof a)
#define ll __int64

using namespace std;
int n;
int low[1010];
int edge[1010][1010];
int ad[1010];

void prime()
{
    int sum=0;
    low[0]=-1;
    for(int i=1;i<n;i++)
        low[i]=edge[0][i];
    for(int i=1;i<n;i++)
    {
        int mi=INF;
        int k;
        for(int j=0;j<n;j++)
        {
            if(low[j]!=-1&&low[j]<mi)
            {
                k=j;
                mi=low[j];
            }
        }
        sum+=mi;
        low[k]=-1;
        for(int j=0;j<n;j++)
        {
            if(edge[k][j]<low[j])
                low[j]=edge[k][j];
        }
    }
    printf("%d\n",sum);
}

int main()
{
//freopen("ceshi.txt","r",stdin);
    int tc;
    scanf("%d",&tc);
    while(tc--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d",&ad[i]);
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
        {
            int x;
            scanf("%d",&x);
            if(i==j)    edge[i][j]=INF;
            else
            {
                edge[i][j]=x+ad[i]+ad[j];
            }
        }
        MEM(low,0);
        prime();
    }
    return 0;
}
</span></span>


 

ZOJ 1258  POJ 1789

题意没啥好说的   将两个字符串比较  给edge赋值  就可以了 

<span style="font-family:KaiTi_GB2312;font-size:18px;">#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>

#define eps 1e-8
#define op operator
#define MOD  10009
#define MAXN  100100
#define INF 0x7fffffff

#define FOR(i,a,b)  for(int i=a;i<=b;i++)
#define FOV(i,a,b)  for(int i=a;i>=b;i--)
#define REP(i,a,b)  for(int i=a;i<b;i++)
#define REV(i,a,b)  for(int i=a-1;i>=b;i--)
#define MEM(a,x)    memset(a,x,sizeof a)
#define ll __int64

using namespace std;

char ch[2010][8];
int low[2010];
int edge[2010][2010];
int n;

void prime()
{
    int sum=0;
    low[0]=-1;
    for(int i=1;i<n;i++)
        low[i]=edge[0][i];
    for(int i=1;i<n;i++)
    {
        int mi=INF;
        int j;
        for(int k=0;k<n;k++)
        {
            if(low[k]!=-1&&low[k]<mi)
            {
                j=k;
                mi=low[k];
            }
        }
        sum+=mi;
        low[j]=-1;
        for(int k=0;k<n;k++)
        {
            if(edge[j][k]<low[k])
                low[k]=edge[j][k];
        }
    }
    printf("The highest possible quality is 1/%d.\n",sum);
}

int main()
{
//freopen("ceshi.txt","r",stdin);

    while(scanf("%d\n",&n)!=EOF)
    {
        if(n==0)  break;
        for(int i=0;i<n;i++)
            scanf("%s",ch[i]);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(i==j)  edge[i][j]=INF;
                if(i<j)
                {
                    int num=0;
                    for(int k=0;k<7;k++)
                    {
                        if(ch[i][k]!=ch[j][k])  num++;
                    }
                    edge[i][j]=edge[j][i]=num;
                }
            }
        }
        prime();
    }
    return 0;
}
</span>


 

 zoj 1914   poj 2349

在前哨之间建立网络，要保证任意两个前哨之间能通过网络进行联系

前哨直接也可以通过卫星频道进行联系  有S个卫星频道   就是有S个前哨可以有卫星频道  可以组成S-1条边

所以  求到最小生成树时   有P个点 有P-1条边  len数组中存储的是0-- P-2（由小到大）  要去除边长最长的前

S-1条边  所以 就是P-2-（S-1）=P-S-1   输出sqrt(len[p-s-1])就可以了

<span style="font-family:KaiTi_GB2312;font-size:18px;">#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>

#define eps 1e-8
#define op operator
#define MOD  10009
#define MAXN  100100
#define INF 0x7fffffff

#define FOR(i,a,b)  for(int i=a;i<=b;i++)
#define FOV(i,a,b)  for(int i=a;i>=b;i--)
#define REP(i,a,b)  for(int i=a;i<b;i++)
#define REV(i,a,b)  for(int i=a-1;i>=b;i--)
#define MEM(a,x)    memset(a,x,sizeof a)
#define ll __int64

using namespace std;
int s,p;
int x[510],y[510];
int low[510];
int edge[510][510];
int len[510];
int cnt;

void prime()
{
    for(int i=0;i<p;i++)
        low[i]=edge[0][i];
    low[0]=-1;
    cnt=0;
    for(int i=1;i<p;i++)
    {
        int mi=INF,j;
        for(int k=0;k<p;k++)
        {
            if(low[k]!=-1&&low[k]<mi)
            {
                j=k;
                mi=low[k];
            }
        }
        len[cnt++]=mi;
        low[j]=-1;
        for(int k=0;k<p;k++)
        {
            if(edge[j][k]<low[k])
                low[k]=edge[j][k];
        }
    }
}


int main()
{
//freopen("ceshi.txt","r",stdin);
    int tc;
    scanf("%d",&tc);
    while(tc--)
    {
        scanf("%d%d",&s,&p);
        for(int i=0;i<p;i++)
        {
            scanf("%d%d",&x[i],&y[i]);
        }
        for(int i=0;i<p;i++)
            for(int j=0;j<p;j++)
        {
            if(i==j)
                edge[i][j]=INF;
            else
            {
                edge[i][j]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                edge[j][i]=edge[i][j];
            }
        }
        prime();
        sort(len,len+cnt);
//    cout<<cnt<<endl;
//    for(int i=0;i<cnt;i++)
//        cout<<len[i]<<"  ";
//    cout<<endl;
//    cout<<len[p-s-1]<<endl;
        printf("%.2lf\n",sqrt((double)(len[p-s-1]*1.0)));
    }
    return 0;
}
</span>

 POJ 1258

<span style="font-family:KaiTi_GB2312;font-size:18px;">#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>

#define eps 1e-8
#define op operator
#define MOD  10009
#define MAXN  100100
#define INF 0x7fffffff

#define FOR(i,a,b)  for(int i=a;i<=b;i++)
#define FOV(i,a,b)  for(int i=a;i>=b;i--)
#define REP(i,a,b)  for(int i=a;i<b;i++)
#define REV(i,a,b)  for(int i=a-1;i>=b;i--)
#define MEM(a,x)    memset(a,x,sizeof a)
#define ll __int64

using namespace std;

int low[110],nearvex[110];
int edge[110][110];
int res;
int n;

void prime()
{
    low[0]=-1;
    for(int i=1;i<n;i++)
    {
        low[i]=edge[0][i];
    }
    for(int i=1;i<n;i++)
    {
        int mi=INF;
        int j;
        for(int k=0;k<n;k++)
        {
            if(low[k]!=-1&&low[k]<mi)
            {
                j=k;
                mi=low[k];
            }
        }
        res+=mi;
        low[j]=-1;
        for(int k=0;k<n;k++)
        {
            if(edge[j][k]<low[k])
                low[k]=edge[j][k];
        }
    }
    printf("%d\n",res);
}

int main()
{
//freopen("ceshi.txt","r",stdin);

    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
        {
            scanf("%d",&edge[i][j]);
            if(i==j)
                edge[i][j]= INF;
        }
        res=0;
        prime();
    }
    return 0;
}
</span>

 poj 3026

题意反正我没怎么看懂 看别人的题解才知道大概是个什么意思

要先通过bfs求出两个点之间的最短距离（A S）

然后再用prime求最小生成树

这个题比较坑  读入两个整数之后还有好多的空格  也要把这些空格读掉

题中给的数据范围感觉有问题  数组一开始开小了  总是过不了

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>
#include <queue>

#define eps 1e-8
#define op operator
#define MOD  10009
#define MAXN  100100
#define INF 0x7fffffff

#define FOR(i,a,b)  for(int i=a;i<=b;i++)
#define FOV(i,a,b)  for(int i=a;i>=b;i--)
#define REP(i,a,b)  for(int i=a;i<b;i++)
#define REV(i,a,b)  for(int i=a-1;i>=b;i--)
#define MEM(a,x)    memset(a,x,sizeof a)
#define ll __int64

using namespace std;
int x,y;
char mp[200][200];
int vis[200][200];
int edge[200][200];
int low[200];
int node[200][200];
int res,num;
int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}};

struct point
{
    int n,m;
    int step;
    bool operator<(const point p)const
    {
        return step>p.step;
    }
};

point p,q;
priority_queue<point> Q;

void bfs(int n,int m)
{
    int nn=node[n][m];
    MEM(vis,0);
    vis[n][m]=1;
    p.n=n; p.m=m; p.step=0;
    Q.push(p);
    while(!Q.empty())
    {
        q=Q.top();  Q.pop();
        if(node[q.n][q.m])
        {
//        cout<<node[q.n][q.m]<<"  ";
            int mm=node[q.n][q.m];
            edge[nn][mm]=q.step;
//        cout<<edge[nn][mm]<<endl;
        }
        for(int i=0;i<4;i++)
        {
            p.n=q.n+dir[i][0];  p.m=q.m+dir[i][1];
            if(p.n>=0&&p.n<y&&p.m>=0&&p.m<x&&!vis[p.n][p.m]&&mp[p.n][p.m]!='#')
            {
                vis[p.n][p.m]=1;
                p.step=q.step+1;
                Q.push(p);
            }
        }
    }
}

void prime()
{
    low[1]=-1;
    for(int i=2;i<=num;i++)
        low[i]=edge[1][i];
    for(int i=2;i<=num;i++)
    {
        int mi=INF;
        int j;
        for(int k=1;k<=num;k++)
        {
            if(low[k]!=-1&&low[k]<mi)
            {
                j=k;
                mi=low[k];
            }
        }
        res+=mi;
        low[j]=-1;
        for(int k=1;k<=num;k++)
        {
            if(edge[j][k]<low[k])
                low[k]=edge[j][k];
        }
    }
    printf("%d\n",res);
}

char tmp[60];

int main()
{
//freopen("ceshi.txt","r",stdin);
    int tc;
    scanf("%d",&tc);
    while(tc--)
    {
        scanf("%d %d",&x,&y);
        gets(tmp);
        num=0;
        MEM(node,0);
        for(int i=0;i<y;i++)
        {
            gets(mp[i]);
            for(int j=0;j<x;j++)
            {
                if(mp[i][j]=='A'||mp[i][j]=='S')
                {
                    num++;
                    node[i][j]=num;
                }
            }
        }
//        for(int i=0;i<y;i++)
//        {
//            for(int j=0;j<x;j++)
//            {
//                cout<<mp[i][j];
//            }
//            cout<<endl;
//        }
        for(int i=0;i<y;i++)
            for(int j=0;j<x;j++)
                if(node[i][j])
                 bfs(i,j);
//        for(int i=1;i<=num;i++)
//        {
//            for(int j=1;j<=num;j++)
//            {
                cout<<edge[i][j]<<" ";
//                if(i==j)
//                    edge[i][j]=INF;
//            }
            cout<<endl;
//        }
        res=0;
        prime();
    }
    return 0;
}

 

理想主义文艺青年
关注
专栏目录
最小生成树的prime算法
04-11
### 最小生成树的Prime算法详解 #### 一、最小生成树定义与应用场景 最小生成树（Minimum Spanning Tree, MST）是指在一个无向图中选取一个子集，该子集包含所有顶点，并且任意两个顶点之间恰好有一条路径相连。在...
prime算法求最小生成树——邻接矩阵（c语言详细代码）（附带案例）
qq_62185081的博客
05-22 2199
此时将{0，3}这条边加入到存储最小生成树的数据结构中，将顶点3加入到已选集合中{0，3}，未选集合为{2，4，5}，这时横向边集合也发生了改变{{0，2}，{0，1}，{0，3}，{3，7}，{3，5}，{3，4}}。Prime算法是切分定理的正向应用。首先选定一个顶点0，当选择一个顶点后就把它看成一个切分，一部分为已选顶点集合{0}，另一部分为未选顶点集合{1，2，3，4，5}。其实很好理解，已选集合{0，2，3，4}中的{0，2}那条边已经没有机会再被选择了，他们内部已经构成了局部最小生成树了。
C++数据结构——习题6-5 最小生成树（Prim算法）
weixin_44546342的博客
05-23 2411
习题6-5 最小生成树 省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。已知村庄数N和可建道路数M，设初始状态下任意村庄之间没有路，请编写程序，根据输入的两村庄间修建道路的费用情况，计算这些村庄畅通所需要的最低成本。 输入格式: 测试数据有多组。每组测试数据第1行输入村庄数目N ( 1< N < 11 )和道路数M；随后的M行输入村庄间道路的成本，每行给3个正整数，分别是两个村庄的编号（从1编号到N），修建此两村庄间
次小生成树个人理解 prime和kruskal两种算法+PTA例题
Shanhj的博客
08-09 353
看网上关于次小生成树的时候一直有点不理解max[i][j]数组的用处，直到自己通过画图才得以理解。 首先讲讲如何求次小生成树，也就是最小生成树之外的最优解。大概的方法就是从未使用的边中（没有被最小生成树包括的边）选一条加入最小生成树，那么肯定会形成一个环了，然后从环中减去最大的一条边即可。而这时候max数组的作用就体现出来了，max[i][j]保存的是从i到j的路径中最长的那一小段路径长度，那么在构成环的时候减去环中除了新边外最大的一条边的时候就很方便了。然后只要遍历所有未使用的边，重复以上步骤，找到最小的
最小生成树-prime算法
Chenyt01的专栏
05-01 541
prime算法的基本思想 1.清空生成树，任取一个顶点加入生成树 2.在那些一个端点在生成树里，另一个端点不在生成树里的边中，选取一条权最小的边，将它和另一个端点加进生成树 3.重复步骤2，直到所有的顶点都进入了生成树为止，此时的生成树就是最小生成树 1090. Highways Constraints Time Limit: 1 secs, Memory Limit:
Networking-POJ 1287(最小生成树）
weixin_44641254的博客
01-14 313
题目链接 前面说到，李云龙集结了所有驻扎在外的部队，想要进攻平安县城，但是平安县城太大了，李云龙的部队太多了，把平安县城围起来之后自己传达命令很不方便，而且由于山本的手下有个狙击手专打通讯员，派遣通讯员很有可能发生意外使得命令传达不到，所以李云龙决定派工程兵修建电话线。由于这是一个危险的任务，而且为了尽快建好通讯电话网络，工程兵需要在最短的时间内建立一个能够传达命令的电话网络。 Input 多样例...
最小生成树prime算法
06-18
数据结构上最小生成树的prime算法，源代码是用c语言实现的，易于大家的理解。
C#实现最小生成树普里姆算法Prime
03-10
普里姆算法（Prim's Algorithm）是解决最小生成树问题的一种经典算法，由捷克数学家Vojtěch Jarník提出，后由美国计算机科学家罗伯特·普里姆改进。 在C#中实现普里姆算法，首先需要理解算法的基本步骤： 1. **...
图的最小生成树Prim算法C++面向对象实现.doc
05-30
Prim算法是求解最小生成树的一种经典算法，由Vojtěch Jarník、Karl Menger和Joseph Kruskal等人独立提出，但以Ernesto Prim的名字最为人所知。 Prim算法的基本思想是从图中任意一个节点开始，逐步添加边，使得...
数据结构实验报告9-图-Prim算法求最小生成树-实验内容与要求.docx
07-06
根据给定的文件信息，本篇内容将围绕“数据结构实验报告9-图-Prim算法求最小生成树”展开，具体涉及的知识点包括Prim算法的基本原理及其应用、图的邻接矩阵存储结构的设计与实现、最小生成树的概念及求解过程、以及...
基于邻接矩阵存储的图的最小生成树的Prime算法
11-26
基于邻接矩阵存储的图的最小生成树的Prime算法，对学习C++和数据结构很有帮助
基于Prim算法实现的最小生成树
最新发布
11-21
前置知识：最小生成树名词概念、最小生成树--Prime算法的基本概念、邻接矩阵基本概念 重点：书中P174 中 图 7.16 与 图 7.17 极其重要，代码中的注释和举例都是基于它们要充分理解 代码阅读与调试 代码调试时间...
Prim算法最小生成树(C语言)
10-16
输入数据: 7 11 A B 7 A D 5 B C 8 B D 9 B E 7 C E 5 D E 15 D F 6 E F 8 E G 9 F G 11 输出: A - D : 5 D - F : 6 A - B : 7 B - E : 7 E - C : 5 E - G : 9 Total:39
随机生成网络，采用prime算法，生成最小生成树Matlab.zip
03-01
本主题聚焦于使用Prime算法在Matlab环境中构建随机网络并寻找其最小生成树。最小生成树是一张加权无向图中边的子集，它连接了所有的节点，且总权重尽可能小。Prime算法是一种经典的最小生成树构造方法，适用于解决这...
prime-tree.rar_tree生成网络图_普鲁姆算法_普鲁母算法_最小生成树_最小生成树 prim
09-24
在提供的压缩包中，`prime-tree.cpp`很可能是一个C++程序，实现了普鲁姆算法来生成最小生成树。这个程序可能包含了数据结构的定义，如邻接矩阵或邻接表，以及算法的具体逻辑。而`www.pudn.com.txt`可能是源代码的...
_11-Prime算法求最小生成树
wl7777777777的博客
11-16 2048
题意： 本题要求你用Prime算法求图的最小生成树。 本题的图都是无向图且最小生成树不存在二义性（包括每一步选入的节点）。 请你输出节点选择的次序和邻接矩阵 思路： 对于记录数据。用邻接矩阵arr记录无向图，用lowCost向量记录v个顶点的最低权重，用visit向量记录顶点是否归入最小树。因为我们先将0号顶点作为最小树的根，所以将其余点与0顶点的权重值作为lowCost的初始值。 对于循环次数。因为已经将0顶点最为最小树的根，所以我们只需再做v-1次循环，每次循...
Prime算法构造最小生成树
qq_51165184的博客
11-16 8175
最小生成树：包含图中全部顶点的极小联通子图。 极小：因为要取全部顶点，所以边要取最少，n个结点最少有n-1条边。边多了可能会导致回路，边少了会不连通。 Prime算法：加点法 假设顶点集V={v0,v1,v2,v3,v4}，U是空集 （1）从顶点集V中任意选取一个顶点放入U，假设选取v0 则U={v0}，V-U={v1 , v2 , v3 , v4 , v5 } cost={(v0 , v1)34，(v0 , v2)46，(v0, v3)∞，(v0 , v4)∞，(v0, v5 )19} .
算法作业1.1：Prime构造最小生成树
weixin_47230213的博客
05-25 302
1、问题： 在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集（即）且为无循环图，使得的 w(T) 最小，则此 T 为 G 的最小生成树。 2、解析 在带权连通图中V是包含所有顶点的集合， U已经在最小生成树中的节点，从图中任意某一顶点v开始，此时集合U={v}，重复...
最小生成树详细讲解（Prime算法+Kruskalsuanfa）
热门推荐
innocence的博客
04-17 1万+
生成树 一个连通图（如果图中任意两点都是连通的，那么图被称作连通图。如果此图是有向图，则称为强连通图（注意：需要双向都有路径））的生成树是该连通图的一个极小连同子图,它含有图中全部顶点,和构成一棵树的(n-1)条边.如果在一棵生成树上添加任何一条边,必定构成一个环,因为这条边使得它依附的那两个顶点之间有了第二条路径.一棵有n个顶点的生成树(连通无回路图)有且仅有(n-1)条边,但是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值