很入门的最小生成树

最新推荐文章于 2024-07-10 17:11:01 发布
原创 最新推荐文章于 2024-07-10 17:11:01 发布 · 110 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

本文详细介绍了如何运用Kruskal算法解决一系列图论问题，包括最小生成树、最大森林、最短路径等。通过实例分析，展示了在不同场景下Kruskal算法的应用，并给出了相应的C++实现代码，帮助读者深入理解Kruskal算法及其在实际问题中的应用。

主要参考lg题单，未来会改会删。
1 lgP2975
开始看数据不大想用prim，想了想还是算了，万一是断断续续的那种不连续的边找已经有了的边对应的顶点不好找。开始被骗了，疯狂re还wa，以为边最多1e3后来仔细读了题看到是“已有的边”，想了想可能是稠密图，且主要思想是把已有了的m条边赋值为0，赋值为0的边最小肯定先算入最小树了，不必像prim一样担心诸如“最小树中的边不包含已有的边该怎么解决”，kruskal很方便。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
const int N=1010,M=2e6+10;//点虽不多但边可能很多，边开小了会re
int cnt;//记录边数
double res;
int p[N],n,m;
struct bian
{
    int x,y;
    double z;
}s[M];
struct node
{
    int x,y;
}dian[N];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    if(a.z==b.z)
        return a.x<b.x;
    return a.z<b.z;
}
void kruskal()
{
    int top=0;
    sort(s+1,s+1+cnt,cmp);
    for(int i=1;i<=cnt;i++)
    {
        if(find(s[i].x)!=find(s[i].y))
        {
            p[find(s[i].x)]=find(s[i].y);
            res+=s[i].z;
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=n;i++)
    {
        cin>>dian[i].x>>dian[i].y;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            cnt++;
            s[cnt].x=i;
            s[cnt].y=j;
            s[cnt].z=(double)sqrt((double)(dian[i].x-dian[j].x)*(dian[i].x-dian[j].x)+(double)(dian[i].y-dian[j].y)*(dian[i].y-dian[j].y));
            //强转一波不然会错
        }
    }
    for(int i=1;i<=m;i++)//之前已有的路再建花费为0
    {
        int x,y;
        cin>>x>>y;
        cnt++;
        s[cnt].x=x;
        s[cnt].y=y;
        s[cnt].z=0.0;//0.0
    }
    kruskal();
    printf("%.2lf",res);
    return 0;
}

2 lgP2121
大水题照着样例想了半天，怪我对kruskal理解不够深刻，被树限制住了，其中对边排序后并查集并非只针对单独一个连通图，连通分量间也可以。这就是一个不一定所有点都连通的、最多k条边的、"最大森林”的边权和。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1e5+10,M=2e5+10;
int p[N],n,m,res,cnt,k;
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
struct bian
{
    int x,y,z;
}s[M];
bool cmp(bian a,bian b)
{
    return a.z>b.z;
}
void kruskal()
{
    sort(s+1,s+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        int x=s[i].x,y=s[i].y,z=s[i].z;
        if(find(y)!=find(x))
        {
            p[find(x)]=find(y);
            res+=z;
            cnt++;
            if(cnt==k)
            {
                cout<<res;
                return;
            }
        }
    }
    return;
}
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        s[i].x=x,s[i].y=y,s[i].z=z;
    }
    kruskal();
    return 0;
}

3 lgP1396
怎么保证最大的最小？边排序后从小到大加边，并查集判断当s和t间第一次互通（即s和t间刚形成最小树时）最大边一定最小。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1e4+10,M=2e4+10;
int p[N],n,m,ss,tt,res,cnt;
struct bian
{
    int a,b,c;
}s[M];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
void kruskal()
{
    sort(s+1,s+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        int a=s[i].a,b=s[i].b,c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            res=max(res,c);
            cnt++;
            if(cnt==n-1 || find(ss)==find(tt))
            {
                cout<<res;
                return;
            }
        }
    }
}
int main()
{
    cin>>n>>m>>ss>>tt;
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        s[i].a=a,s[i].b=b,s[i].c=c;
    }
    kruskal();
    return 0;
}

4 lgP1195
起初想法是只需要k个点就行，找k个点的最小树的权值和。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1e3+10,M=1e4+10;
int p[N],n,m,k,res,cnt,ans;
bool st[N];
struct bian
{
    int a,b,c;
}s[M];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
void kruskal()
{
    sort(s+1,s+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        int a=s[i].a,b=s[i].b,c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            res+=c;
            cnt++;
            if(cnt==n-1 && ans<k)
            {
                cout<<"No Answer";
                return;
            }
            if(st[a]==false)
            {
                st[a]=true;
                ans++;
            }
            if(st[b]==false)
            {
                st[b]=true;
                ans++;
            }
            if(ans==k)
            {
                cout<<res;
                return;
            }
        }
    }
}
int main()
{
    cin>>n>>m>>k;
    if(k>n)
    {
        cout<<"No Answer";
    }
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        s[i].a=a,s[i].b=b,s[i].c=c;
    }
    kruskal();
    return 0;
}

交了一发全wa发现好像理解错了，原来棉花糖不是连线的才算一个，图中所有的都算，而一个树只对应一个棉花糖。。。所以完全想反了，反而是只需要连n-k条最小边，自然就有k个连通分量（棉花糖）了。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1e3+10,M=1e5+10;
int p[N],n,m,k,res,cnt;
struct bian
{
    int a,b,c;
}s[M];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
void kruskal()
{
    sort(s+1,s+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        int a=s[i].a,b=s[i].b,c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            res+=c;
            cnt++;
            if(cnt==n-k)
            {
                cout<<res;
                return;
            }
        }
    }
    cout<<"No Answer";
}
int main()
{
    cin>>n>>m>>k;
    if(n-k>m)
    {
        cout<<"No Answer";
        return 0;
    }
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        s[i].a=a,s[i].b=b,s[i].c=c;
    }
    kruskal();
    return 0;
}

5 lgP1194
开始又在纠结不连通可能导致多个起点，后来一想太水了，有多个连通分量也可以化成一个起点，办法是除了第一个起点，买其它点的花费都记在与前一个点连着的边上，所以即使不连通的分量间也可以画出一条默认花费的边使其连通，因此连出的最小树就是最小的花费。将这些边从小到大比较至于起点的花费单独加一下一个点的默认花费。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1100,M=1e6+10;
int p[N],n,m,res,cnt,ans;
struct bian
{
    int a,b,c;
}s[M];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
void kruskal()
{
    sort(s+1,s+1+ans,cmp);
    for(int i=1;i<=ans;i++)
    {
        int a=s[i].a,b=s[i].b,c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            res+=c;
            cnt++;
            if(cnt>=m)
                return;
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
        p[i]=i;
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=m;j++)
        {
            int x;
            cin>>x;
            if(i!=j)
            {
                ans++;
                s[ans].a=i;
                s[ans].b=j;
                if(x==0)
                {
                    s[ans].c=n;
                    continue;
                }
                s[ans].c=min(n,x);//优惠反而更贵换成默认值
            }
        }
    }
    kruskal();
    cout<<res+n;
    return 0;
}

6 lgP1991
间接相连也算，找最短路边从小到大排序，注意n>=m特判，找需要用无线电的m-n条小边中最大的即为D。

#include <bits/stdc++.h>
using namespace std;
const int N=1010,M=1e4+10;
int p[N],n,m,cnt,ans;
double res=0.0;
struct node
{
    int x,y;
}d[N];
struct bian
{
    int x,y;
    double z;
}s[M];
double dis(node a,node b)
{
    return (double)sqrt(pow((double)(a.x-b.x),2)+pow((double)(a.y-b.y),2));
}
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.z<b.z;
}
void kruskal()
{
    sort(s+1,s+1+ans,cmp);
    for(int i=1;i<=ans;i++)
    {
        int a=s[i].x,b=s[i].y;
        double c=s[i].z;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            res=max(res,c);
            cnt++;
            if(cnt==m-n)
                return;
        }
    }
}
int main()
{
    cin>>n>>m;
    if(n>=m)
    {
        cout<<0;
        return 0;
    }
    for(int i=1;i<=m;i++)
        p[i]=i;
    for(int i=1;i<=m;i++)
    {
        cin>>d[i].x>>d[i].y;
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=m;j++)//无向边
        {
            if(i!=j)
            {
                ans++;
                s[ans].x=i;
                s[ans].y=j;
                s[ans].z=dis(d[i],d[j]);
            }
        }
    }
    kruskal();
    printf("%.2lf",res);
    return 0;
}

7 lgP2700
基本同上，离着近的肯定划分为一个部落，最小树上最远的k-1条边一定连着k个部落，所以找到最小树中第n-k+1小的边就行。

#include <bits/stdc++.h>
using namespace std;
const int N=2e3+10,M=4e6+10;
int p[N],n,k,cnt,ans;
double res;
struct bian
{
    int a,b;
    double c;
}s[M];
struct node
{
    int x,y;
}d[N];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
double dis(node a,node b)
{
    return (double)sqrt(pow((double)(a.x-b.x),2)+pow((double)(a.y-b.y),2));
}
void kruskal()
{
    sort(s+1,s+1+ans,cmp);
    for(int i=1;i<=ans;i++)
    {
        int a=s[i].a,b=s[i].b;
        double c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            res=max(res,c);
            cnt++;
            if(cnt==n-k+1)
            {
                return;
            }
        }
    }
}
int main()
{
    cin>>n>>k;
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=n;i++)
    {
        cin>>d[i].x>>d[i].y;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            ans++;
            s[ans].a=i;
            s[ans].b=j;
            s[ans].c=dis(d[i],d[j]);
        }
    }
    kruskal();
    printf("%.2lf",res);
    return 0;
}

8 lgP1967
开始觉得没想错，一画图觉得我忘了一种情况，敌人通过敌人没占领的点也可以到别的敌人所在点。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1e5+10,M=1e6+10;
const int INF=0x3f3f3f3f;
typedef long long LL;
int p[N],n,m,k,cnt;
LL res;
bool st[N];
struct bian
{
    int a,b,c;
}s[M];
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
void kruskal()
{
    sort(s,s+m+1,cmp);
    for(int i=0;i<m;i++)
    {
        int a=s[i].a,b=s[i].b,c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(a)]=find(b);
            if(c==INF)
            {
                cout<<res;
                return;
            }
            res+=c;
            cnt++;
        }
    }
}
int main()
{
    LL sum=0;
    cin>>n>>k;
    m=n-1;
    for(int i=0;i<=m;i++)
        p[i]=i;
    while (k -- )
    {
        int x;
        cin>>x;
        st[x]=true;
    }
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        s[i].a=a;
        s[i].b=b;
        if(st[a]&&st[b])
            s[i].c=c;
        else
            s[i].c=INF;
        sum+=c;
    }
    if(k==n)
    {
        cout<<sum;
        return 0;
    }
    for(int i=0;i<m;i++)
        cout<<s[i].c<<' ';
    kruskal();
    return 0;
}

建最大边，总的减去就是不符合的最小边。改了之后还是有错，错在并查集上。

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10,M=1e6+10;
const int INF=0x3f3f3f3f;
typedef long long LL;
int p[N],n,k,cnt;
LL ans;
bool st[N];
struct bian
{
    int a,b,c;
}s[M];
bool cmp(const bian &a,const bian &b)
{
    return a.c>b.c;
}
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin>>n>>k;
    for(int i=1;i<=n;i++)
        p[i]=i;
    while (k -- )
    {
        int x;
        cin>>x;
        st[x]=true;
    }
    for(int i=1;i<=n-1;i++)
    {
        cin>>s[i].a>>s[i].b>>s[i].c;
        ans+=s[i].c;
    }
    sort(s+1,s+n,cmp);
    for(int i=1;i<=n-1;i++)
    {
        int r1=find(s[i].a),r2=find(s[i].b);
        if(st[r1] && st[r2])//都并入敌人集合，这条边不建
            continue;
        p[r1]=r2;//为什么将r1并入r2中就错？？？
        if(st[r1]==true)//并入敌人集合后也算敌人
            st[r2]==true;
        else if(st[r2]==true)
            st[r1]=true;
        ans-=s[i].c;
    }
    printf("%lld",ans);
    return 0;
}

在这里插入图片描述
注意不要并错集合，并查集只在根节点上有意义。上面把r2并入r1中就是ac代码如下。

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10,M=1e6+10;
const int INF=0x3f3f3f3f;
typedef long long LL;
int p[N],n,k,cnt;
LL ans;
bool st[N];
struct bian
{
    int a,b,c;
}s[M];
bool cmp(bian a,bian b)
{
    return a.c>b.c;
}
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
void kruskal()
{
    sort(s+1,s+n,cmp);
    for(int i=1;i<=n-1;i++)
    {
        if(!(st[find(s[i].a)] && st[find(s[i].b)]))
        {
            p[find(s[i].b)]=find(s[i].a);
            st[find(s[i].a)]=(st[find(s[i].a)]||st[find(s[i].b)]);
            ans-=s[i].c;
        }
    }

}
int main()
{
    cin>>n>>k;
    for(int i=1;i<=n;i++)
        p[i]=i;
    while (k -- )
    {
        int x;
        cin>>x;
        st[x]=true;
    }
    for(int i=1;i<=n-1;i++)
    {
        cin>>s[i].a>>s[i].b>>s[i].c;
        ans+=s[i].c;
    }
    kruskal();
    printf("%lld",ans);
    return 0;
}

在这里插入图片描述
9 lgP1536
开始思路是将连通的边都标记为0，不太容易标记。
索性直接kruskal判断已连通的边的个数cnt，如果等于n-1说明n个点已连通无需再添边；否则添加n-1-cnt条边才能连通。

#include <bits/stdc++.h>
using namespace std;
const int N=1010,M=2e6+10;
int p[N],n,m,res,cnt;
bool st[N][N];
struct bian
{
    int a,b,c;
}s[M];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
int main()
{
    while(scanf("%d%d",&n,&m))
    {
        cnt=0;
        if(n==0)
            break;
        for(int i=1;i<=n;i++)
            p[i]=i;
        for(int i=1;i<=m;i++)
            cin>>s[i].a>>s[i].b;
        sort(s+1,s+1+m,cmp);
        for(int i=1;i<=m;i++)
        {
            int a=s[i].a,b=s[i].b,c=s[i].c;
            if(find(a)!=find(b))
            {
                p[find(a)]=find(b);
                cnt++;
            }
        }
        if(cnt==n-1)
        {
            cout<<0<<endl;
            continue;
        }
        else
            cout<<n-1-cnt<<endl;
    }
    return 0;
}

10 lgP2916
这题挺有意思，点上的权值怎么办？我们注意到每经历一条边去一个农场再回来时边权可以化成：两端点权值和+边权*2，别忘了起点在开始时就需要多加一次，最小树不变起点选最小的就行。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=10010,M=2e5+10;
int p[N],n,m,res,cnt,w[N],minw=0x3f3f3f3f;
struct bian
{
    int a,b,c;
}s[M];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
void kruskal()
{
    sort(s+1,s+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        int a=s[i].a,b=s[i].b,c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(b)]=find(a);
            res+=c;
            cnt++;
            if(cnt==n-1)
                return;
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        p[i]=i;
    for(int i=1;i<=n;i++)
    {
        cin>>w[i];
        minw=min(minw,w[i]);//最小树不变，多劝一次的起点当然选选最小点
    }
    for(int i=1;i<=m;i++)
    {
        cin>>s[i].a>>s[i].b>>s[i].c;
        s[i].c=s[i].c*2+w[s[i].a]+w[s[i].b];
    }
    kruskal();
    cout<<res+minw;
    return 0;
}

11 lgP1340
吸氧之后过了。
数据很小对每一步prim一次，注意上一步最短边的状态不一定能用，因为之后可能有更小的边输入。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=210,M=4e4+10;
int dist[N],n,m,res,cnt;
bool st[N];
int g[N][N];
bool prim()
{
    memset(dist,0x3f,sizeof dist);
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(st[j]==false &&(t==-1 || dist[t]>dist[j]))
                t=j;
        }
        st[t]=true;
        if(i!=1 && dist[t]==0x3f3f3f3f)
            return false;
        if(i!=1)
            res+=dist[t];
        for(int j=1;j<=n;j++)
        {
            if(dist[j]>g[t][j])
                dist[j]=g[t][j];
        }
    }
    return true;
}
int main()
{
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while (m -- )
    {
        memset(st,false,sizeof st);
        res=0,cnt=0;
        int a,b,c;
        cin>>a>>b>>c;
        if(g[a][b]>c)
            g[a][b]=g[b][a]=c;
        if(prim())
            cout<<res<<endl;
        else
            cout<<-1<<endl;
    }
    return 0;
}

12 lgP1265

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
const int N=5050,M=5e7+10;
int p[N],n,m,cnt,ans=0;
double res;
struct bian
{
    int a,b;
    double c;
}s[M];
struct node
{
    int x,y;
}d[N];
bool cmp(bian a,bian b)
{
    return a.c<b.c;
}
double dis(node a,node b)
{
    return (double)sqrt((double)pow((a.x-b.x),2)+(double)pow((a.y-b.y),2));;
}
int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}
void kruskal()
{
    sort(s+1,s+1+ans,cmp);
    for(int i=1;i<=ans;i++)
    {
        int a=s[i].a,b=s[i].b;
        double c=s[i].c;
        if(find(a)!=find(b))
        {
            p[find(b)]=find(a);
            res+=c;
            cnt++;
            if(cnt==n-1)
                printf("%.2lf",res);
        }
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) p[i]=i;
    for(int i=1;i<=n;i++)
        cin>>d[i].x>>d[i].y;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            ans++;
            s[ans].a=i;
            s[ans].b=j;
            s[ans].c=dis(d[i],d[j]);
        }
    }
    kruskal();
    return 0;
}

在这里插入图片描述
竟然卡空间5000*5000。
5000 *5000用于存边，而空间限制不许存边，又因为是稠密图所以改用prim。prim是找点，所以边不需要邻接矩阵存，直接用两点求即可。

#include <bits/stdc++.h>
using namespace std;
const int N=5050;
int n;
double dist[N],res;
bool st[N];
struct node
{
    int x,y;
}d[N];
double dis(node a,node b)
{
    return (double)sqrt((double)pow((a.x-b.x),2)+(double)pow((a.y-b.y),2));;
}
void prim()
{
    for(int i=1;i<=n;i++)
        dist[i]=100000000;
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(st[j]==false && (t==-1 || dist[t]>dist[j]))
                t=j;
        }
        st[t]=true;
        if(i!=1 && dist[t]==100000000)
            return;
        if(i!=1)
            res+=dist[t];
        for(int j=1;j<=n;j++)
        {
            double dd=dis(d[t],d[j]);
            if(dist[j]>dd)
                dist[j]=dd;
        }
    }
    printf("%.2lf",res);
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>d[i].x>>d[i].y;
    prim();
    return 0;
}
杪渊探骊
关注
力扣刷题之旅：高阶篇（四）—— 最小生成树算法
欢迎来到“Python算法探索”，我是GT算法工程师，一名热爱计算机算法的博主。在这里，我们将一起深入探索Python世界中的各种算法，从基础到高级，从理论到实践。我参加过很多算法比赛，积累了丰富的经验，希望通过这个播客与你分享。让我们一起用Python探
02-12 1079
本文介绍了力扣刷题之旅的高阶篇（）—— 最小生成树算法。通过一道关于最小生成树的题目，我们学习了如何使用Kruskal算法找到加权无向图中的最小生成树，并给出了Python代码示例。最小生成树算法在实际应用中具有广泛的用途，如网络设计、电路设计等。通过不断刷题和学习算法知识，我们可以提高自己的编程能力和解决问题的能力。
最小生成树(Prim、Kruskal)算法，秒懂！
热门推荐
bigsai
09-30 4万+
前言 在数据结构与算法的图论中，(生成)最小生成树算法是一种常用并且和生活贴切比较近的一种算法。但是可能很多人对概念不是很清楚，什么是最小生成树? 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 通俗易懂的讲就是最小生成树包含原图的所有节点而只用最少的边和最小的权值距离。因为n个节点最少需要n-1个边联通，而距离就需要采取某种策略选择恰当的边。 学习最
最小生成树
ZhuRanCheng的博客
08-18 3万+
最小生成树总结
kruskal 生成最小树
chutzpah
01-31 925
kruskal 算法在排序上最费时，生成树过程复杂度是线性的，所以最终复杂度为o(|E|log|V|)。 可以对比一下prim算法 传送门》》题目链接#include<stdio.h> #include<string.h> #include<queue> #include<algorithm> #define INF 0x3f3f3f3f using namespace std; int cos
最小生成树(算法篇)
最新发布
hellmorning的博客
07-10 1781
本文将会讲解算法之中的最小生成树，最小生成树按理来说是一个数据结构，但是形成最小生成树的算法相比较才更重要，本文将会讲解prim和krusal算法来生成最小生成树
图论- 最小生成树
qwertyasdfghh的博客
03-29 3621
在题中只给出一个点的坐标，我们需要想方法转换为两个点的链接，所以需要将每个点（两个坐标组合）转换为一个符号标记，在链接数组把相连的两个符号放一起就行了，很明显，我们使用0-n-1来记录每一个点是最合适的，不仅方便遍历也一目了然。的高度只存在于平衡二叉树，对于一般的树可能出现极端不平衡的情况，使得「树」几乎退化成「链表」，树的高度最坏情况下可能变成。因为无论树长啥样，树上的每个节点的根节点都是相同的，所以能不能进一步压缩每棵树的高度，使树高始终保持为常数？我们可能习惯性地认为树的高度就是。
图生成最小树
z_h_a_o的专栏
01-11 613
<br />#include"stdio.h" #include"malloc.h" #define L 10 #define C 10 #define MAX_Ver 30 typedef int VertexType; typedef int Graphkind; typedef int InfoType ; typedef struct ArcCellj { int adj; InfoType *info; }ArcCell, AdjMatrix[L][C]; typedef struct { Ver
精选资源
数学建模入门之最小生成树
01-13
数学建模入门之最小生成树 数学建模是美国大学生数学建模竞赛的重要组成部分，其中最小生成树是数学建模入门的关键概念。最小生成树是指连接所有顶点且总路径最小的树形结构。在本文中，我们将详细讲解最小生成树的...
ACM入门-最小生成树及其应用
TGX的博客
12-14 1532
前置知识 邻接矩阵、并查集 什么是最小生成树？ 今天要讲解的算法是最小生成树，那么什么是最小生成树呢？由于是面向新手的算法教程，尽量用大白话来讲清楚最小生成树这个定义。 假定有这么一个问题，有6个城市，城市之间有一些道路，修道路需要花费不同的金额，现在要你选择其中一些道路，使得所有城市可以互相到达（联通）且花费最小。这个问题的答案就是最小生成树，我们把这个问题抽象为一张图，每个城市是一个点，城市与城市的道路是一条无向边。 如何求解这个问题？ Prim算法 算法思路：将所有城市分为两个集合，一个集合X是已经
matlab 绘制最小生成树 prim法,最小生成树问题---Prim算法与Kruskal算法实现（MATLAB语言实现）...
weixin_36326408的博客
03-16 3110
2015-12-17晚，复习，甚是无聊，阅《复杂网络算法与应用》一书，得知最小生成树问题(Minimum spanning tree)问题。记之。何为树：连通且不含圈的图称为树。图T=(V,E),|V|=n,|E|=m,下列关于树的说法等价：T是一个树。T无圈，且m=n-1。T连通，且m=n-1。T无圈，但每加一新边记得到唯一一个圈。T连通，但任舍去一边就不连通。T中任意两点，有唯一道路相连。何为...
最小生成树快速入门教程【Prim&Kruskal】
2301_80089588的博客
05-14 2449
最适合小白的最小生成树入门，内含Prim，Kruskal算法！
最小生成树详解
m0_69349401的博客
08-09 1万+
最小生成树来啦！
最小生成树算法
胜天半子祁厅的博客
09-11 1503
图的概念“最小生成树”中树的含义：1、结构中不能形成环；2、必须连接图结构中的全部节点（即，任意两个顶点间都是互通的）。综上所述，对于一个有nnn个节点的树，其边的条数是n−1n-1n−1。“最小生成树”中最小的含义：对于一个图，可以有很多树，把树各边的权值相加，称为权值和。不同的生成树有不同的权值和，最小生成树就是最小生成树。官方定义（晦涩难懂）：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。
【arcpy学习实践教程】利用krusal最小树方法生成最小树
桃花浪子的专栏
08-28 707
【需求】将两两生成的最短路径生成最小树 【分析】根据最小树的原理编写程序，利用图来生成最小树 #! /usr/bin/env python #coding:utf-8 #以全局变量X定义节点集合，即类似{'A':'A','B':'B','C':'C','D':'D'},如果A、B两点联通，则会更改为{'A':'B','B':'B",...},即任何两点联通之后，两点的值value将相同。 ...
数据结构之最小树生成算法
Richard_666的博客
01-26 992
 
生成最小树（普里姆算法与库鲁斯卡尔算法）
qq_45781812的博客
07-01 1312
普里姆算法 基本思想：以某个顶点为起点，逐步找各顶点上最小权值的边来构建最小树。 代码如下： vector<vector<int>> edges;//邻接矩阵 int N;//N为顶点数 //普里姆算法，从编号为0顶点开始 void prim() { vector<int> index(N, 0);//储存对应顶点的下标，初始化为第一个顶点的下标0 vector<int> lowcost(edges[0]);//表示已加入生成树的顶点到其他顶点之间权值的最
两种最小生成树的方法——普里姆算法、克鲁斯卡尔算法
三粒花生米的博客
01-06 1万+
一、最小生成树的概念 在连通网的所有生成树中，所有边的代价和最小的生成树。 二、MST性质 构建最小生成树的算法有多种，比如普里姆算法、克鲁斯卡尔算法。其中多数算法利用了最小生成树的下列一种简称MST的性质。 1、性质 假设N=( V , { E } )是一个连通网，U是顶点集V的一个非空子集。若（u，v）是一条具有最小权值的边，其中u∈U，v∈V-U，则必存在一颗包含边（u，v）的最小生成树。 图1 连通图N 2、...
数据结构实验3:生成最小树
BlackCarDriver的博客
05-15 1716
数据结构实验3 ：图的遍历生成树 实验内容及原理 键盘输入n个顶点和m条边(6<=n<=16,n-1<=m<=20)及相应权重，建立图的邻居矩阵和邻接表的存储形式，并输出该邻接矩阵和邻接表。 用Prim算法求其最小生成树。函数 void Prim(AMGraph G, VerTexType u) 以及输出边集数组的函数 void PrintEdge(Edgeset Sed...
Java实现最小生成树：数据结构入门
《数据结构与算法在Java中》是一本由Robert Lafore编写的经典教材，于2001年由Release Team出版，英文原版名为"Data Structures & Algorithms in Java"，ISBN号为1571690956，由Sams出版社在1998年发行，共617页。...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值