Prim算法和Kruskal算法求最小生成树

AcWing 858. Prim算法求最小生成树

给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。
求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。
给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合n=|V|，m=|E|。
由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。

输入格式
第一行包含两个整数n和m。
接下来m行，每行包含三个整数u，v，w，表示点u和点v之间存在一条权值为w的边。

输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

数据范围
1≤n≤500,
1≤m≤10⁵,
图中涉及边的边权的绝对值均不超过10000。

输入样例：
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例：
6

朴素版Prim算法思路:
该算法与dijkstra算法比较类似，本算法将dist数组定义为某点到集合的距离（即该点到集合内部所有边的长度最小值）。先将dist数组的值初始化为无穷大，n次循环查找，找到集合外距离最近的点，并用找到的点更新其他点到集合的距离，最后将该点加入到集合中。若找到的最近的点的dist值还是为无穷大，则说明不存在最小生成树。邻接矩阵存稠密图。

Code：

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

const int N = 510, INF = 0x3f3f3f3f;
int n, m;
int g[N][N], dist[N];//g为邻接矩阵存放边的信息
bool st[N];

int prim()
{
    memset(dist, 0x3f, sizeof dist);
    
    int res = 0;//边权重之和
    for(int i = 0; i < n; i ++)//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];
        
        for(int j = 1; j <= n; j ++)  dist[j] = min(dist[j], g[t][j]);
        
        st[t] = true;
    }
    
    return res;
}

int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    
    int t = prim();
    if(t == INF)  puts("impossible");
    else cout << t << endl;
    
    return 0;
}

AcWing 859. Kruskal算法求最小生成树

给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。
求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。
给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。
由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。

输入格式
第一行包含两个整数n和m。
接下来m行，每行包含三个整数u，v，w，表示点u和点v之间存在一条权值为w的边。

输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

数据范围
1≤n≤10⁵,
1≤m≤2∗10⁵,
图中涉及边的边权的绝对值均不超过1000。

输入样例：
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例：
6

Kruskal算法思路：
先将所有边按权重从小到大排序，然后枚举每条边a, b以及权重w, 若a,b不连通，将该边加入到连通块中（该步可以采用并查集的算法）。

Code:

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 1000010;
int n, m, p[N];

struct Edge{
    int a, b, w;
    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[N];

int find(int x)
{
    if(p[x] != x)  p[x] = find(p[x]);
    return p[x];
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i < m; i ++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edges[i] = {a, b, w};
    }
    
    sort(edges, edges + m);
    
    for(int i = 1; i <= n; i ++)  p[i] = i;
    
    int res = 0, cnt = 0;
    for(int i = 0; i < m; i ++)
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        a = find(a), b = find(b);
        if(a != b)
        {
            p[a] = b;
            res += w;// res存放累加的边权重之和
            cnt ++;//添加到集合里的边的个数
        }
    }
    
    if(cnt < n - 1)  puts("impossible");//边的个数不够说明生成数不存在
    else cout << res << endl;
    
    return 0;
}

洛谷P2872 [USACO07DEC]Building Roads S

给定 n 个点的坐标，第 i 个点的坐标为 (xi,yi)，这 n 个点编号为 1 到 n。给定 m 条边，第 i条边连接第 ui个点和第 vi 个点。现在要求你添加一些边，并且能使得任意一点都可以连通其他所有点。求添加的边的总长度的最小值。

输入格式：
第一行两个整数 n,m代表点数与边数。
接下来 n 行每行两个整数 xi,yi 代表第 i 个点的坐标。
接下来 m 行每行两个整数 ui,vi 代表第 i 条边连接第 ui个点和第 vi 个点。

输出格式：
一行一个实数代表添加的边的最小长度，要求保留两位小数，为了避免误差， 请用 64 位实型变量进行计算。

输入样例：
4 1
1 1
3 1
2 3
4 3
1 4
输出 样例：
4.00

数据规模与约定
对于 100% 的整数，1 ≤ n,m ≤1000，1≤ xi, yi ≤10⁶, 1≤ ui,vi ≤n。

Kruskal算法题目思路：
本题主要运用了Kruskal算法，本题需要注意的是边权的问题，首先要将所有点之间的距离计算出来记入edges数组中，由于有些点之间是已经连通的，所以将这些边的边权设为0.0即可，其余的就是Kruskal算法（将所有按权重从小到大排序，枚举每条边，若不连通就将该边加入到集合中，边权累加到最终结果中）。

Code:

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
using namespace std;

const int N = 1010, M = 1000010;
int n, m;
int x[N], y[N], p[N];

struct Edge{
    int a, b;
    double w;
    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

double computeDist(int a, int b, int c, int d)
{
    return  sqrt(pow((double)(a-c), 2) + pow((double)(b-d), 2));
}

int find(int x)
{
    if(p[x] != x)  p[x] = find(p[x]);
    return p[x];
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i ++)   
    {
        cin >> x[i] >> y[i];
        p[i] = i;
    }
    
    int k = 0;
    for(int i = 1; i <= n - 1; i ++)
        for(int j = i + 1; j <= n; j ++)
        {
            edges[k ++]={i, j, computeDist(x[i],y[i],x[j],y[j])};
        }    
             
    while(m --)
    {
        int a, b;
        cin >> a >> b;
        edges[k ++] = {a, b, 0.0};
    }
    
    sort(edges, edges + k);
    
    double res = 0.0;
    for(int i = 0; i < k; i ++)
    {
        int a = edges[i].a, b = edges[i].b;
        double w = edges[i].w;
        a = find(a), b = find(b);
        if(a != b)
        {
            p[a] = b;
            res += w;
        }
    }
    
    printf("%.2lf", res);
    return 0;
}