算法刷题【洛谷P1661】扩散（三种解法：最小生成树 + 二分&并查集 + Floyd弗洛伊德）

本文链接：https://blog.csdn.net/weixin_44495599/article/details/123032068

异想之旅：本人原创博客完全手敲，绝对非搬运，全网不可能有重复；本人无团队，仅为技术爱好者进行分享，所有内容不牵扯广告。本人所有文章仅在CSDN、掘金和个人博客（一定是异想之旅域名）发布，除此之外全部是盗文！

洛谷 P3383 线性筛素数

题目描述

一个点每过一个单位时间就会向四个方向扩散一个距离，如图。

两个点a、b连通，记作e(a,b),当且仅当a、b的扩散区域有公共部分。连通块的定义是块内的任意两个点u、v都必定存在路径e(u,a0),e(a0,a1),…,e(ak,v)。给定平面上的n给点，问最早什么时刻它们形成一个连通块。

输入格式

第一行一个数n，以下n行，每行一个点坐标。

输出格式

一个数，表示最早的时刻所有点形成连通块。

输入输出样例

In 1：

2
0 0
5 5

Out 1：

数据范围

对于20%的数据，满足1≤N≤5; 1≤X[i],Y[i]≤50;

对于100%的数据，满足1≤N≤50; 1≤X[i],Y[i]≤10^9。

题解

先谢罪，我承认这次使用了一个阴间的类定义来实现并查集……但是大家可以看一看，如果有Python类定义的基础还是十分好懂的

实在看不懂，就把本题中的并查集的实现跳过就好，反正我相信你也是会的[旺柴]

老师又要开始讲课了，先把三种算法的题解放出来，注释和详解等着再补充……（有人看的话还请点赞或评论或私信下防止我忘了）

最小生成树Kruskal算法

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

int n, a[55][2], len, ans, cnt;

class bcj {
   public:
    int f[50000];
    void init() {
        for (int i = 1; i <= n; i++) f[i] = i;
    }
    void merge(int x, int y) {
        int p = find(x), q = find(y);
        if (p == q) return;
        f[p] = q;
    }
    int find(int x) {
        if (f[x] == x) return x;
        return f[x] = find(f[x]);
    }
} b;

struct edges {
    int x, y, v;
} e[50005];

bool cmp(edges a, edges b) { return a.v < b.v; }

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i][0] >> a[i][1];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            len++;
            e[len].x = i;
            e[len].y = j;
            e[len].v = abs(a[i][0] - a[j][0]) + abs(a[i][1] - a[j][1]);
        }
    }

    sort(e + 1, e + len + 1, cmp);

    b.init();
    for (int i = 1; i <= len && cnt < n; i++) {
        if (b.find(e[i].x) != b.find(e[i].y)) {
            b.merge(e[i].x, e[i].y);
            ans = e[i].v;
            cnt++;
        }
    }

    cout << (ans + 1) / 2 << endl;

    return 0;
}

二分+并查集

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

const int N = 55;
int n, a[N][2], m[N][N];

class bcj {
   public:
    int f[N];
    void init() {
        for (int i = 1; i <= n; i++) f[i] = i;
    }
    void merge(int x, int y) {
        int p = find(x), q = find(y);
        if (p == q) return;
        f[p] = q;
    }
    int find(int x) {
        if (f[x] == x) return x;
        return f[x] = find(f[x]);
    }
};

bool check(int mid) {
    bcj b;
    b.init();
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (m[i][j] <= mid) b.merge(i, j);
    int f = b.find(1);
    for (int i = 2; i <= n; i++)
        if (b.find(i) != f) return false;
    return true;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i][0] >> a[i][1];
    }

    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            m[i][j] = m[j][i] = abs(a[i][0] - a[j][0]) + abs(a[i][1] - a[j][1]);
        }
    }

    int l = 0, r = 1e9 + 5, mid;
    while (l <= r) {
        mid = l + r >> 1;
        if (check(mid))
            r = mid - 1;
        else
            l = mid + 1;
    }

    cout << int(l + 1) / 2 << endl;

    return 0;
}

Floyd弗洛伊德算法

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

const int N = 55;
int n, x[N], y[N], d[N][N], ans;

int main() {
    memset(d, 1e9, sizeof(d));
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> x[i] >> y[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            d[i][j] = d[j][i] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
        }
    }

    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == j || i == k || j == k) continue;
                d[i][j] = min(d[i][j], max(d[i][k], d[k][j]));
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            ans = max(ans, d[i][j]);
        }
    }

    cout << int(ans + 1) / 2 << endl;

    return 0;
}