最小生成树专题

最新推荐文章于 2025-06-04 13:41:23 发布
最新推荐文章于 2025-06-04 13:41:23 发布 · 104 阅读 · 0

本文通过POJ平台上的三道经典题目，详细介绍了两种求解最小生成树(MST)问题的算法：Kruskal算法和Prim算法。每种算法都提供了完整的C/C++代码实现，并对关键步骤进行了注释说明。

poj2421,poj2560,poj1789

这些都是一些比较基础的最小生成树的题目，在这里我分别用两种方法来实现--kruskal以及prim(其中prim是建哥写的,kruskal是我写的).

//poj2421 kruskal
#include <iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f
int n,m;
int a[105][105],d;
int p[105],xa,yb;
int sum,res;
typedef struct Node
{
    int value;
    int l;
    int r;
};
Node edges[105*105];
int find_set(int x)
{
    if(x!=p[x])
        p[x]=find_set(p[x]);
    return p[x];
}
bool cmp(Node e1,Node e2)
{
    return e1.value<e2.value;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        p[i]=i;
    }
    int sym=0,mm=0,m=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&d);
            a[i][j]=a[j][i]=d;

        }
    }
    scanf("%d",&mm);
    for(int i=0;i<mm;i++)
    {
        scanf("%d%d",&xa,&yb);
        a[xa][yb]=0;

    }
    for(int i=1;i<n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            edges[m].l=i;
            edges[m].r=j;
            edges[m].value=a[i][j];
            m++;
        }
    }
    sort(edges,edges+m,cmp);
    for(int i=0;i<m;i++)
    {
        int fx=find_set(edges[i].l);
        int fy=find_set(edges[i].r);
        if(fx!=fy)
        {
            sum+=edges[i].value;
            p[fy]=fx;
        }

    }
    printf("%d\n",sum);

  return 0;
}

//poj2421 prim
#include <stdio.h>
#include <string.h>

#define INF 0x3f3f3f3f

int maps[305][305];
bool vis[305];
int dis[305];
int n;

int Prim()
{
    memset(vis,false,sizeof(vis));
    for(int i=1; i<=n; i++)
        dis[i] = INF;
    int ans=0;
    dis[1] = 0;
    for(int i=1; i<=n; i++)
    {
        int tmp = INF,k=0;
        for(int j=1; j<=n; j++)
        {
            if(!vis[j]&&dis[j]<tmp)
            {
                tmp = dis[j];
                k=j;
            }
        }

        vis[k] = true;
        ans+=tmp;
        for(int i=1; i<=n; i++)
        {
            if(!vis[i]&&dis[i]>maps[k][i])
                dis[i] = maps[k][i];
        }
    }
    return ans;
}

int main()
{
    while(scanf("%d",&n),n)
    {
        for(int i=0; i<=n; i++)
        {
            for(int j=0; j<=n; j++)
                if(i==j)
                    maps[i][j]=0;
                else maps[i][j] = INF;
        }
        for(int i=0; i<n-1; i++)
        {
            int t;
            char a[2],b[2];
            scanf("%s%d",a,&t);
            for(int j=0; j<t; j++)
            {
                int dist;
                scanf("%s%d",b,&dist);
                maps[a[0]-'A'+1][b[0]-'A'+1] = maps[b[0]-'A'+1][a[0]-'A'+1] = dist;
            }
        }
        printf("%d\n",Prim());
    }
    return 0;
}

//poj2560 kruskal

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
int t;
typedef struct Node
{
    double x;
    double y;
};
typedef struct Edge
{
    int l;
    int r;
    double value;
};
Edge edges[105*105];
Node node[105];
int p[105],n;
double sum;
bool cmp(Edge e1,Edge e2)
{
    return e1.value<e2.value;
}
int find_set(int x)
{
    if(x!=p[x])
        p[x]=find_set(p[x]);
    return p[x];
}
int main()
{
    sum=0;
    scanf("%d",&n);

    for(int i=1;i<=n;i++)
    {
        scanf("%lf%lf",&node[i].x,&node[i].y);
        p[i]=i;
    }
    int m=0;
   for(int i=1;i<=n;i++)
   {
       for(int j=1;j<=n;j++)
       {
            double d=sqrt((node[i].x-node[j].x)*(node[i].x-node[j].x)+(node[i].y-node[j].y)*(node[i].y-node[j].y));
            edges[m].l=i;
            edges[m].r=j;
            edges[m++].value=d;
       }
   }

    sort(edges,edges+m,cmp);

   /* for(int i=0;i<m;i++)
    {
        printf("%lf\n",edges[i].value);
    }*/

    for(int i=0;i<m;i++)
    {
        int fx=find_set(edges[i].l);
        int fy=find_set(edges[i].r);
        if(fx!=fy)
        {
            sum+=edges[i].value;
            p[fy]=fx;
        }
    }
    printf("%.2lf\n",sum);
    return 0;
}

//poj 2560 prim
#include <stdio.h>
#include <string.h>
#include <math.h>

#define INF 0x3f3f3f3f

int n;
double maps[300][300];
bool vis[300];
double dis[300];

struct Point {
    double x;
    double y;
}points[300];

double Prim()
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)
        dis[i] = INF;

    dis[1] = 0;
    double ans =0;
    for(int i=1;i<=n;i++)
    {
        double tmp = INF;
        int k =0;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]<tmp)
            {
                tmp = dis[j];
                k= j;
            }
        }

        vis[k]=true;
        ans+=tmp;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&dis[i]>maps[k][i])
                dis[i] = maps[k][i];
        }
    }
    return ans;
}

int main()
{

    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%lf%lf",&points[i].x,&points[i].y);

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            double x = points[i].x - points[j].x;
            double y = points[i].y - points[j].y;
            maps[i][j] = sqrt(x*x+y*y);
        }
    }
    printf("%.2lf\n",Prim());

    return 0;
}

//poj1789 kruskal

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n;
char str[2050][10];
int p[2050];
typedef struct Edge
{
  int l;
  int r;
  int value;
};
bool cmp(Edge e1,Edge e2)
{
    return e1.value<e2.value;
}
int find_set(int x)
{
    if(x!=p[x])
        p[x]=find_set(p[x]);
    return p[x];
}
Edge edges[2050*2050];
int getDif(int x,int y)
{
    int num=0;
    for(int i=0;i<7;i++)
    {
        if(str[x][i]!=str[y][i])
        {
            num++;
        }
    }
    return num;
}
int main()
{

    while(scanf("%d",&n)&&n!=0)
    {
        memset(edges,0,sizeof(edges));
        memset(str,0,sizeof(str));
        int m=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%s",str[i]);
            p[i]=i;
        }

        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
            {
                int num=getDif(i,j);
                edges[m].l=i;
                edges[m].r=j;
                edges[m++].value=num;
            }
        }
        sort(edges,edges+m,cmp);
        int sum=0;
        for(int i=0;i<m;i++)
        {
            int fx=find_set(edges[i].l);
            int fy=find_set(edges[i].r);
            if(fx!=fy)
            {
                sum+=edges[i].value;
                p[fy]=fx;
            }
        }
        printf("The highest possible quality is 1/%d.\n",sum);

    }

return 0;

}

//poj1789 prim
#include <stdio.h>
#include <string.h>

#define INF 0x3f3f3f3f

int maps[2005][2005];
char str[2005][2005];
int dis[2005];
bool vis[2005];
int n;

int Prim()
{
    memset(vis,false,sizeof(vis));
    for(int i=1; i<=n; i++)
        dis[i] = INF;
    int ans=0;
    dis[1] = 0;
    for(int i=1; i<=n; i++)
    {
        int tmp = INF,k=0;
        for(int j=1; j<=n; j++)
        {
            if(!vis[j]&&dis[j]<tmp)
            {
                tmp = dis[j];
                k=j;
            }
        }

        vis[k] = true;
        ans+=tmp;
        for(int i=1; i<=n; i++)
        {
            if(!vis[i]&&dis[i]>maps[k][i])
                dis[i] = maps[k][i];
        }
    }
    return ans;
}

int main()
{
    while(scanf("%d",&n),n)
    {
        for(int i=0;i<n;i++)
            scanf("%s",str[i]);

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                int dist = 0;
                for(int k=0;k<7;k++)
                {
                    if(str[i][k]!=str[j][k])
                        dist++;
                }
                maps[i+1][j+1] = dist;
            }
        }
        printf("The highest possible quality is 1/%d.\n",Prim());
    }
    return 0;
}

 

【图论】【最小生成树】最优布线问题
蒟蒻的OI路
12-21 684
Description 学校有n台计算机，为了方便数据传输，现要将它们用数据线连接起来。两台计算机被连接是指它们之间有数据线连接。由于计算机所处的位置不同，因此不同的两台计算机的连接费用往往是不同的。 当然，如果将任意两台计算机都用数据线连接，费用将是相当庞大的。为了节省费用，我们采用数据的间接传输手段，即一台计算机可以间接的通过若干台计算机（作为中转）来实现与另一台计算机的连接。 现在由你负责连...
最小生成树（Minimum Spanning Tree, MST）
07-01 1786
以下是Prim算法在C++中的实现。这个实现使用了优先队列（堆）来选择权重最小的边，并逐步构建最小生成树。中，使得所有节点连通且总权重最小的一棵树。设置图的顶点和边，调用 Kruskal 算法并输出最小生成树。实现Prim算法，使用优先队列（最小堆）来选择最小权重的边。并查集实现，用于管理顶点集合，并支持路径压缩和按秩合并。以下是Kruskal算法在C++中的实现。：设置图的顶点和边，调用Prim算法并输出最小生成树。这个实现适用于任意无向加权图，并高效地找到最小生成树。Kruskal算法的实现。
Stable Match 【HDU - 1435】【稳定婚姻系统】
既然弱小，就只顾变强就是了
07-26 246
题目链接 题意是中文的，但是却很难理解的说：我们给出C个（我在代码里用N来表示），有N个发射器和N个接收器，要求是让发射器与接收器达成稳定匹配，也就是稳定婚姻匹配问题了。 我们先把每个发射器到接收器的距离都处理出来，然后就是比较大小，然后婚姻匹配了（我这都没加上比较容量的，就过了）。 #include <iostream> #include <cstdio>...
C++ sort()函数cmp的含义
yeeanna的博客
09-17 2331
C++ sort函数
ACM最小生成树专题练习集
weixin_35636570的博客
06-04 600
在图论中，最小生成树是一个经典的概念，它是图中包含所有顶点，并且边的权重和最小的树。最小生成树的目的是在给定的加权连通图中找到这样一个子图，即它是一棵树，涵盖了图中的所有顶点，并且边的权重之和最小。这个概念在计算机网络设计、电路设计、城市规划以及解决其他需要最小连接成本的问题中有着广泛的应用。Kruskal's算法是一种用于在加权连通图中找到最小生成树的贪心算法。最小生成树是指在一个加权连通图中找到一个边的子集，这些边构成树形结构且包含图中的所有顶点，同时边的权值之和最小。
省赛复习(3) 最小生成树专题
weixin_51934288的博客
05-17 181
P8074 [COCI2009-2010#7] SVEMIR 要求出min{|x_A-x_B|,|y_A-y_B|,|z_A-z_B|}，数量级为1e5，若是两两相连，等差数列为n*(n-1)/2肯定会MLE，超出内存。 因此，注意边长间的关系。当两个点x距离很近时，表达式得到的值最小，同理y,z也是。因此会想到排三次序，每次排序连接相邻的两个点,数量级为最大为3e5. kruskral算法的复杂度O(e*loge), prim算法的复杂度为O(n*n)，可脱离边。 prim算法复杂度为O(n*loge),
最小生成树 专题之prim算法与kruskal
yyj的博客之旅
07-18 334
本篇博客来自南昌理工学院acm队 写作缘由：复习和重新练习最小生成树。 最小生成树 1.作者建议： 对于学习最小生成树最好是明白以下关于图的概念： (1).连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。 (2).强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。 (3).连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。 (4).
最小生成树专题1 最小生成树-Prim算法
Angindem博客
10-26 108
输出 4 输出 -1 Prim 算法和 朴素版的 Dijkstra 有点类似，也叫做 朴素版Prim算法，但也还是有点区别。Dijkstra 中，只要起点到目的点的最短距离。最小生成树，表示 不定某个起点和终点，要求遍历完所有点的 最短距离。所以，朴素版的 Prim 和 朴素版的 Dijkstra 很相似。区别在于更新 dist 的时候，Dijkstra 更新的是距离，Prim 更新的是 集合之间的
贪心算法题解（最小生成树专题）
ZY的博客
11-25 1029
A. 最小生成树 Description 在一张图上有N个点，点与点之间的连接的花费都已经告诉你了，请你设计一下，如何解决这个“最小生成树”的问题。要求用prim方法求解。 Input 首先输入一个数字N（0〈=N〈=100） ​ 然后输入一个N*N的矩阵 其中第i行第j列的数字k表示从点i到点j需要的花费。 Output 一个数字，最少需要多少花费才能使得整张图任意两点都直接或者间接连通（也就是最小生成树的权） Sample Input 5 0 41 67 34 0 41 0 69 24 78 67
并查集&最小生成树专题
weixin_44070289的博客
07-26 304
并查集：朴素并查集和带权并查集 并查集介绍 视频讲解 难点：路径压缩和启发式合并的理解 常用模板： (1)朴素并查集： int p[N]; //存储每个点的祖宗节点 // 返回x的祖宗节点 int find(int x) { if (p[x] != x) p[x] = find(p[x]); return p[x]; } // 初始化，假定节点编号是1~n for (int i = 1; i <= n; i
【最小生成树专题】POJ 2075 Tangled in Cables
荷叶田田
03-11 489
POJ 2075 Tangled in Cables 题目链接－&gt;http://poj.org/problem?id=2075 Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 6810   Accepted: 2661 Description You are the owner o...
[宫水三叶的刷题日记]：（图论）最小生成树1
08-03
《宫水三叶的刷题日记》系列主要探讨的是图论中的一个重要概念——最小生成树。最小生成树问题是在加权无向图中找到一棵包括所有顶点的树，使得树的所有边的权重之和尽可能小。在这个专题中，作者通过一系列的题目，...
最小生成树专题 F - Truck History（prime模板算法）
大梦小半
08-16 239
题意 ： 什么鬼的汽车公司有个惊人的发现，吧啦吧啦吧啦…………….然后就给你n个卡车的车牌（我就没见过这种车牌），每2辆车的车牌中，有多少个字母不同就代表着这两辆车经历的多少年的演变。然后就让你求所有的这些车至少经历了多少年的演变。 这道题类似于坐标构图，数据量有些大 ，然后就： 。。。不好意思贴错了，是这个： 妈耶，疯狂优化以后终于AC了。。。。 最后发现是被string类型的...
高校如何建立科研人员驻企服务的考核标准？_1.docx
12-16
高校如何建立科研人员驻企服务的考核标准？_1
大学如何评估中试基地对区域经济的拉动效应？.docx
12-16
大学如何评估中试基地对区域经济的拉动效应？
IMG_0338.jpg
12-16
IMG_0338.jpg
安卓应用源码Android仿百度地图气泡程序源码
最新发布
12-16
安卓应用源码Android 仿百度地图气泡程序源码
MYVU 2.48.8 安装包
12-16
MYVU 安装包 版本号 2.48.8。
深度解析：生成树算法与最小生成树
"生成树专题，深入讲解生成树算法，包括多路增广、最小瓶颈生成树等概念。由清华大学唐文斌讲解。" 生成树是图论中的一个重要概念，它是一个无向图的子图，包含原图的所有顶点，并且构成一棵树——即没有环路的连通...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值