P3366 【模板】最小生成树（prim+链式前向星+kruskal）

题目链接 https://www.luogu.com.cn/problem/P3366

你，作为一个模板题，我真的要恨恨地夸你几句 :）

点捏的真好，WA了N遍，这题（和队长）让我明白了一个人生道理：条条道路通罗马

                                                                                             TuT

---

Prim：——（4.13）

①选取一个点作为顶点，此点生成一个树

②找到与树连接的任意一点的最短距离，将此点纳入树中

③重新计算树与其他点最短的距离

④循环②③步，直到生成了最小生成树或无法生成树

#include<bits/stdc++.h>
using namespace std;

int n,m;//n个点，m个边
long long x,y,z;//输入起点、终点、边权值
long long cnt;//记录边数
long long sum;//输出和
int book[5010];//标记数组
long long dis[200010];//记录距离树的距离最短路程
long long MAX=99999;//边界值
int maps[5010][5010];//存图

void Prim()
{
    book[1]=1;//标记1已经被访问

    for(register long long i=1;i<=n-1;i++) //因为1已经访问过，所以循环n-1次
    {
        int min=MAX;
        int minIndex=0;
        //寻找离树最近的点
        for(register long long j=1;j<=n;j++)
        {
            if(book[j]==0&&dis[j]<min)//j没有被访问过，且i到j有边连接
            {
                min=dis[j];
                minIndex=j;
            }
        }

        book[minIndex]=1;//标记此点已被访问
        sum+=dis[minIndex];
        cnt++;
        //如果不能联通所有点
        if(min==MAX) break;

        for(register long long j=1; j<=n; j++)
        {   //更新当前最小生成树到其他点的最小距离
            //即：如果这点没有被访问过，而且这个点到任意一点的距离比现在到树的距离近那么更近
            if(book[j]==0&&maps[minIndex][j]<dis[j])
                dis[j]=maps[minIndex][j];//就将更小值放入dis数组
        }
    }
}

int main()
{
    std::ios::sync_with_stdio(false);
    cin>>n>>m;

    //初始化maps，除了自己到自己的点为0，其余为边界值
    for(register long long i=1; i<=n; i++)
    {
        for(register int j=1; j<=n; j++)
        {
            if(i==j) maps[i][j]=0;
            else maps[i][j]=MAX;
        }
    }

    //输入无向图
    for(register long long i=1; i<=m; i++)
    {
        cin>>x>>y>>z;
        if(z<maps[x][y])//条条大路通罗马
        {   //无向图，对称矩阵
            maps[x][y]=z;
            maps[y][x]=z;
        }
    }

    //初始化距离数组，默认从顶点1开始计算，并把1能够到达的点放进dis数组
    for(register long long i=1; i<=n; i++)
    {
        dis[i]=maps[1][i];
    }

    Prim();
    //判断是否能生成
    if(cnt>=n-1) cout<<sum<<endl;
    else cout<<"orz";
    return 0;
}

---

 

链式前向星：——（4.14）

（一个好写的、易用的邻接表）

这个理解了好久，一直在看文字搞不懂head数组的含义，也不明白加边加在什么地方、怎么加。后来看了个视频讲解就懂了https://www.bilibili.com/video/BV1mJ411S7BB?spm_id_from=333.337.search-card.all.click

给当时的我解答困惑：

比如有一条路是这样连接的：a->b->c->NULL

①加边加在每一条通路的最前面，也就是链表的头部，a的前面

②链式前向星的输入和遍历顺序是相反的，遍历的时候从c开始遍历

③head数组用来记录以i为起点在数组中的第一位存储位置，方便进行①操作。head数组初始化为0（或-1）

#include<bits/stdc++.h>
#define maxn 5005//顶点
#define maxm 200005//边
#define MAX 99999
using namespace std;

int head[maxm];//记录以i为起点在数组中的第一位存储位置，方便在第一位之前插入
int dis[maxm];//记录最短距离
int tot;//记录读到第几条边
int n,m;//点、边
int u,v,w;//起点、终点、权值
int ans,cnt;//最小生成树的各边长度和/已生成cnt条边
bool vis[maxn];//标记

struct edge
{
    int v;
    int w;
    int next;//与第i条边同起点的下一条存储位置
} e[maxm<<1]; //无向图，开两倍数组

//加边
void add(int u,int v,int w)
{
    e[++tot].v=v;
    e[tot].w=w;
    e[tot].next=head[u];//与下一句合并在一起是链表的插入操作
    head[u]=tot;
}

int Prim()
{
    int now=1;//假设从顶点1开始计算
    for(int i=2; i<=n; i++)
        dis[i]=MAX;
    //条条道路通罗马
    for(int i=head[1]; i!=0; i=e[i].next)
        dis[e[i].v]=min(dis[e[i].v],e[i].w);

    while(++cnt<n)
    {
        int minn=MAX;
        vis[now]=1;

        //找没有被标记的点，找出最小值最为新边
        for(int i=1; i<=n; i++)
        {
            if(!vis[i]&&minn>dis[i])
            {
                minn=dis[i];
                now=i;
            }
        }
        ans+=minn;

        //如果不能联通所有点
        if(minn==MAX) break;

        //更新
        for(int i=head[now]; i!=0; i=e[i].next)
        {
            int v=e[i].v;
            if(!vis[v]&&dis[v]>e[i].w)
                dis[v]=e[i].w;
        }
    }
    return ans;
}

int main()
{
    cin>>n>>m;
    for(int i=1; i<=m; i++)
    {
        cin>>u>>v>>w;
        add(u,v,w);
        add(v,u,w);//无向图
    }
    Prim();
    if(cnt>=n-1) cout<<ans<<endl;
    else cout<<"orz";
    return 0;
}

---

 

Kruskal：——（4.15）

在学习kruskal之前需要学习并查集。作用：判断是否形成环。

个人觉得kruskal真的会比prim好想很多.....

将所有的边排序，每次选取最小的边放入树中，当然，在放入树之前要判断两个点是否已经在同一个集合（树）中。

用kruscal算法解决这道题不需要特判是否有重边（也就是上面所说的条条道路通罗马），因为我们按照边的权值排序放入，如果a点到b点有重边且目前还未都纳入树中，那么我们会先将权值小的边放入树中，此时两个点已经全部纳入树中，当循环到重边时会跳过。

#include<bits/stdc++.h>
using namespace std;
int n,m;//点，边
long long cnt,ans;
int s[500010];//保存父节点

struct Edge
{
    int u;//起点
    int v;//终点
    int w;//权值
} edge[500010];

bool cmp(Edge a,Edge b)
{
    return a.w<b.w;
}

int Find(int o)
{
    return s[o]==o?o:Find(s[o]);
}

int Kruskal()
{
    for(register int i=1; i<=n; i++)
    {
        s[i]=i;//i的父节点为s[i]
    }
    sort(edge+1,edge+m+1,cmp);
    for(register int i=1; i<=m; i++)
    {
        int x=Find(edge[i].u);
        int y=Find(edge[i].v);
        if(x==y)
            continue;
        ans+=edge[i].w;
        cnt++;
        s[y]=x;
        if(cnt==n-1)
            break;
    }
    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(register int i=1; i<=m; i++)
        cin>>edge[i].u>>edge[i].v>>edge[i].w;
    Kruskal();
    if(cnt>=n-1)
        cout<<ans<<endl;
    else
        cout<<"orz"<<endl;
    return 0;
}

---

呜呜呜痛并快乐着