【最小生成树题单】

洛谷链接

P3366

模板。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;

int n, m;
int res, cnt;
int p[maxn];
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        res += w;
        cnt++;
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);
    for (int i = 1; i <= n; i++)
        p[i] = i;
    for (int i = 0; i < m; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    if (cnt < n - 1)
        return -1;
    return res;
}

int main()
{
    cin >> n >> m;

    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }

    int t = kruskal();
    if (t == -1)
        cout << "impossible" << endl;
    else
        cout << t << endl;
}

P2330

本题要求求的就是瓶颈MST（最大边权最小的生成树）
而一棵最小生成树必定是一棵最小瓶颈生成树。
所以我们直接做一遍最小生成树即可

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;

int n, m;
int res, cnt;
int p[maxn];
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        res = max(res, w);
        cnt++;
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);
    for (int i = 1; i <= n; i++)
        p[i] = i;
    for (int i = 0; i < m; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    if (cnt < n - 1)
        return -1;
    return res;
}

int main()
{
    cin >> n >> m;

    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }

    kruskal();

    cout << n - 1 << " " << res << endl;
}

P1546

换皮模板。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;

int n, idx;
int res, cnt;
int p[maxn];
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        res += w;
        cnt++;
    }
}

int kruskal()
{
    sort(edges, edges + idx, cmp);
    for (int i = 1; i <= n; i++)
        p[i] = i;
    for (int i = 0; i < idx; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    if (cnt < n - 1)
        return -1;
    return res;
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            int x;
            cin >> x;
            edges[idx++] = {i, j, x};
        }
    int t = kruskal();
    cout << t << endl;
}

P2872

给定点的坐标而非边，需要自己求边。
记得开double

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;

int n, m, idx;
int p[maxn];
double res;
struct edge
{
    int a, b;
    double w;
} edges[maxn];
pair<int, int> node[maxn];

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

double query(int _, int __)
{
    auto a = node[_], b = node[__];

    return (double)sqrt((double)(a.first - b.first) * (a.first - b.first) + (double)(a.second - b.second) * (a.second - b.second));
}

void init()
{
    for (int i = 1; i <= n; i++)
    {
        int x, y;
        cin >> x >> y;
        node[i] = {x, y};
    }

    for (int i = 0; i < m; i++)
    {
        int a, b;
        cin >> a >> b;
        edges[idx++] = {a, b, 0};
    }

    for (int i = 1; i <= n; i++)
        for (int j = i; j <= n; j++)
            edges[idx++] = {i, j, query(i, j)};
}

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

void Union(int a, int b, double w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        res += w;
    }
}

double kruskal()
{

    sort(edges, edges + idx, cmp);
    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < idx; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    return res;
}

int main()
{
    cin >> n >> m;
    init();
    printf("%.2lf", kruskal());
    //sort(edges, edges + idx, cmp);
    // for(int i=0;i<idx;i++)
    //     cout<<edges[i].a<<" "<<edges[i].b<<" "<<edges[i].w<<endl;
}

P1547

模板。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;

int maxx = -1;
int n, m;
int p[maxn];
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        maxx = max(maxx, w);
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < m; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    return maxx;
}

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};
    }

    cout << kruskal();
}

P2820

题目要求去掉的连线长度最大，即剩下的长度最小。
总长度减去最小生成树的长度即可。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;

int n, m;
int res, tmp;
int p[maxn];
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        res += w;
        p[a] = b;
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < m; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    return res;
}

int main()
{
    cin >> n >> m;

    for (int i = 0; i < m; i++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        tmp += w;
        edges[i] = {a, b, w};
    }

    cout << tmp - kruskal();
}

P1195

模板。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;

int n, m, k;
int cnt, res;
int p[maxn];
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        cnt++;
        res += w;
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;
    for (int i = 0; i < m; i++)
    {
        Union(edges[i].a, edges[i].b, edges[i].w);
        if (cnt == n - k)
            break;
    }

    if (cnt < n - k)
        return -1;
    return res;
}

int main()
{
    cin >> n >> m >> k;

    for (int i = 0; i < m; i++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edges[i] = {a, b, w};
    }

    int t = kruskal();
    if (t == -1)
        cout << "No Answer" << endl;
    else
        cout << t << endl;
}

P1194

注意没优惠或者反向优惠的需要原价购买即可。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e7 + 10;

int n, m;
int p[maxn];
int cnt, res, idx;
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b && w != 0 && w <= n)
    {
        p[a] = b;
        res += w;
        cnt++;
    }
}

int kruskal()
{
    sort(edges, edges + idx, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < idx; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    if (cnt < m - 1)
        return res + (m - cnt) * n;
    return res + n;
}

int main()
{
    cin >> n >> m;

    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= m; j++)
        {
            int x;
            cin >> x;
            edges[idx++] = {i, j, x};
        }

    cout << kruskal();
}

P2121

看懂题意就是模板题。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;

int n, m, k;
int p[maxn];
int cnt, res;
struct edge
{
    int a, b, w;
} edges[maxn];

bool cmp(edge a, edge b)
{
    return a.w > b.w;
}

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        res += w;
        cnt++;
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < m; i++)
    {
        Union(edges[i].a, edges[i].b, edges[i].w);
        if (cnt == k)
            break;
    }

    return res;
}

int main()
{
    cin >> n >> m >> k;

    for (int i = 0; i < m; i++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edges[i] = {a, b, w};
    }

    cout << kruskal();
}

P1396

倍增、最短路、最小生成树都能做。
对于kruskal算法而言，使u、v同处于一个集合的最后一条边即为答案（kruskal的本质）

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;

int n, m, s, t;
int p[maxn];
int cnt, res;
struct edge
{
    int a, b, w;
} edges[maxn];

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        p[a] = b;
        res += w;
        cnt++;
    }
}

int kruskal()
{
    sort(edges, edges + m, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < m; i++)
    {
        Union(edges[i].a, edges[i].b, edges[i].w);
        if (find(s) == find(t))
            return edges[i].w;
    }
}

int main()
{
    cin >> n >> m >> s >> t;

    for (int i = 0; i < m; i++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edges[i] = {a, b, w};
    }

    cout << kruskal();
}

P1991

卫星电话通话距离无限制（有s个卫星电话则可以存在s个集合）
每一对哨所之间的通话距离都是同一个 D（最小D是最大边）

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;

int s, p;
int cnt, idx;
double ans;
int f[400];
pair<int, int> node[maxn];
struct edge
{
    int a, b;
    double w;
} edges[maxn];

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

double query(int i, int j)
{
    auto a = node[i], b = node[j];

    return (double)sqrt((double)(a.first - b.first) * (a.first - b.first) + (double)(a.second - b.second) * (a.second - b.second));
}

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

void Union(int a, int b, double w)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        f[a] = b;
        ans = w;
        cnt++;
    }
}

double kruskal()
{
    sort(edges, edges + idx, cmp);

    for (int i = 1; i <= p; i++)
        f[i] = i;

    for (int i = 0; i < idx; i++)
    {
        Union(edges[i].a, edges[i].b, edges[i].w);
        if (cnt == p - s)
            return ans;
    }
}

int main()
{
    cin >> s >> p;

    for (int i = 1; i <= p; i++)
    {
        int x, y;
        cin >> x >> y;
        node[i] = {x, y};
    }

    for (int i = 1; i <= p; i++)
        for (int j = 1; j <= p; j++)
            edges[idx++] = {i, j, query(i, j)};

    printf("%.2lf", kruskal());
}

P1265

数据范围太大，kruskal必然MLE（要存下每条边并排序）。
考虑prim算法，只在需要边时计算，防止MLE。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 10, inf = 0x3f3f3f3f;
typedef pair<int, int> pii;

double dist[maxn];
bool st[maxn];
int n, m;
pii node[maxn];

double query(int a, int b)
{
    auto u = node[a], v = node[b];
    return (double)sqrt((double)(u.first - v.first) * (u.first - v.first) + (double)(u.second - v.second) * (u.second - v.second));
}

double prim()
{
    memset(dist, 0x7f, sizeof dist);
    dist[1] = 0;
    double res = 0;

    for (int i = 0; i < n; i++)
    {
        int t = -1;
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        st[t] = true;

        if (i)
            res += dist[t];

        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], query(t, j));
    }

    return res;
}

int main()
{
    cin >> n;

    for (int i = 1; i <= n; i++)
    {
        int x, y;
        cin >> x >> y;
        node[i] = {x, y};
    }
    printf("%.2lf", prim());
}

P2212

模板。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e7 + 10;

int n;
double k;
int p[maxn];
long long cnt, idx;
double res;
pair<int, int> node[maxn];
struct edge
{
    int a, b;
    long long w;
} edges[maxn];

long long query(int a, int b)
{
    auto u = node[a], v = node[b];
    return (u.first - v.first) * (u.first - v.first) + (u.second - v.second) * (u.second - v.second);
}

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

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

void Union(int a, int b, int w)
{
    a = find(a);
    b = find(b);
    if (a != b && w >= k)
    {
        p[a] = b;
        cnt++;
        res += w;
    }
}

long long kruskal()
{
    sort(edges, edges + idx, cmp);

    for (int i = 1; i <= n; i++)
        p[i] = i;

    for (int i = 0; i < idx; i++)
        Union(edges[i].a, edges[i].b, edges[i].w);

    if (cnt < n - 1)
        return -1;
    return res;
}

int main()
{
    cin >> n >> k;

    for (int i = 1; i <= n; i++)
    {
        int x, y;
        cin >> x >> y;
        node[i] = {x, y};
    }

    for (int i = 1; i <= n; i++)
        for (int j = i; j <= n; j++)
            edges[idx++] = {i, j, query(i, j)};

    cout << kruskal();
}