专题六 最小生成树

最新推荐文章于 2022-03-28 10:54:14 发布
最新推荐文章于 2022-03-28 10:54:14 发布
阅读量234 收藏 1
点赞数
分类专栏： ACM-kuangbin带我飞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49959202/article/details/113578289
版权
这个专题详细讲解了最小生成树的相关问题，包括多个在线编程比赛中的实例，如POJ 1251, POJ 1287等。通过解决这些题目，展示了如何运用最小生成树算法解决实际问题，如构建网络、道路建设等。涉及到的解题策略包括经典的Prim和Kruskal算法，以及特殊情况的处理和优化。" 82425991,7916642,深入理解JSP基础与核心概念,"['java', 'jsp', 'web开发', '服务器', '基础教程']
摘要由CSDN通过智能技术生成

文章目录

专题六 最小生成树

POJ 1251 Jungle Roads

题意： 给一张图，求最小生成树

题解： 模板提

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>

using namespace std;

typedef long long LL;
int const MAXN = 40;
int n, m, T, tot;
map<string, int> mp;
int g[MAXN][MAXN], dis[MAXN], st[MAXN];

// prime算法
int prime()
{
    memset(dis, 0x3f, sizeof dis);  // dis初始化
    memset(st, 0, sizeof st);
    int res = 0;  // 记录最小生成树的距离和
    for (int i = 0; i < n; ++i)  // 外循环n次
    {
        int t = -1;  // 记录到集合最小的点
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dis[j] < dis[t]))
                t = j;  // 找到t
        if (i && dis[t] == 0x3f3f3f3f) return dis[t];  // 如果集合内有点且t点到集合的距离为无穷(即表示t不在连通图内)， 不存在最小生成树
        if (i) res += dis[t];  // 如果集合内有点，累加res
        for (int j = 1; j <= n; ++j)  // 更新所有与t连接的点
            dis[j] = min(dis[j], g[t][j]);
        st[t] = 1;  // 把t放入集合
    }
    return res;  // 返回res
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    while(cin >> n){
        if (!n) break;
        memset(g, 0x3f, sizeof g);
        mp.clear();
        tot = 0;
        for (int i = 0, t; i < n - 1; ++i) {
            string s1, s;
            cin >> s1 >> t;
            if (!mp.count(s1)) mp[s1] = ++tot;
            for (int j = 0, tt; j < t; ++j) {
                cin >> s >> tt;
                if (!mp.count(s)) mp[s] = ++tot;
                g[mp[s1]][mp[s]] = g[mp[s]][mp[s1]] = min(g[mp[s]][mp[s1]], tt);
            }
        }
        cout << prime() << endl;
    }
    return 0;
}

POJ 1287 Networking

题意： 给定n个点m条边，求最小生成树。

题解： 裸题

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>

using namespace std;

int const N = 5e2 + 10, M = 1e5 + 10;
int g[N][N], dis[N], st[N];
int n, m;

// prime算法
int prime() {
    memset(dis, 0x3f, sizeof dis);  // dis初始化
    memset(st, 0, sizeof st);
    int res = 0;  // 记录最小生成树的距离和
    for (int i = 0; i < n; ++i) {// 外循环n次
        int t = -1;  // 记录到集合最小的点
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dis[j] < dis[t]))
                t = j;  // 找到t
        if (i && dis[t] == 0x3f3f3f3f) return dis[t];  // 如果集合内有点且t点到集合的距离为无穷(即表示t不在连通图内)， 不存在最小生成树
        if (i) res += dis[t];  // 如果集合内有点，累加res
        for (int j = 1; j <= n; ++j)  // 更新所有与t连接的点
            dis[j] = min(dis[j], g[t][j]);
        st[t] = 1;  // 把t放入集合
    }
    return res;  // 返回res
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        if (!n) break;
        memset(g, 0x3f, sizeof g);  // 初始化邻接矩阵
        for (int i = 0; i < m; ++i) {// 读入边信息
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            g[a][b] = g[b][a] = min(g[a][b], c);  // 无向图注意要赋值两次
        }
        cout << prime() << endl;
    }
    return 0;
}

POJ 2031 Building a Space Station

题意： 空间有很多球…

题解： 求任意2个球圆心距离，如果距离大于两个半径和，那么就是距离-半径和，要不然就是0，然后跑最小生成树

代码： 代码有点不想写了，贴上其他人的：https://blog.csdn.net/In_Youth/article/details/47080187?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <climits>
using namespace std;
double maz[109][109];
double d[109];
bool vis[109];
double dis(double a[], double b[])
{
    double x, y, z, sum;
    x = (a[0] - b[0]) * (a[0] - b[0]);
    y = (a[1] - b[1]) * (a[1] - b[1]);
    z = (a[2] - b[2]) * (a[2] - b[2]);
    sum = sqrt((x + y + z) * 1.0);
    sum = sum - (a[3] + b[3]);
    return sum;
} //得到两点之间的距离！
void prim(int n)
{
    int i, j, pos;
    double sum, t;
    for (i = 1; i <= n; ++i)
        d[i] = maz[1][i];
    memset(vis, false, sizeof(vis));
    vis[1] = true;
    sum = 0;
    for (i = 0; i < n - 1; ++i)
    {
        t = INT_MAX;
        for (j = 1; j <= n; ++j)
        {
            if (!vis[j] && d[j] < t)
            {
                t = d[j];
                pos = j;
            }
        }
        sum += t;
        vis[pos] = true;
        for (j = 1; j <= n; ++j)
        {
            if (!vis[j] && d[j] > maz[pos][j])
            {
                d[j] = maz[pos][j];
            }
        }
    }
    printf("%.3lf\n", sum);
}
int main()
{
    int t, i, j;
    double data[109][9], tem;
    while (~scanf("%d", &t) && t)
    {
        for (i = 1; i <= t; ++i)
        {
            for (j = 1; j <= t; ++j)
                maz[i][j] = i == j ? 0 : INT_MAX;
        } //初始化maz数组
        for (i = 1; i <= t; ++i)
        {
            for (j = 0; j < 4; ++j)
                scanf("%lf", &data[i][j]);
        } //保存原始数据
        for (i = 1; i <= t; ++i)
        {
            for (j = i + 1; j <= t; ++j)
            {
                tem = dis(data[i], data[j]);
                if (tem <= 0)
                    maz[i][j] = maz[j][i] = 0;
                else
                    maz[i][j] = maz[j][i] = tem;
            }
        }        //用两层for循环计算任意两点之间的距离，将最后结果保存在maz数组里
        prim(t); //模板prim算法
    }
    return 0;
}

POJ 2421 Constructing Roads

题意： 输入一个n * n的矩阵，表示任意2个点的距离。然后给定q对数字a和b，表示a和b之间已经连通。现在要修公路，使得任意2个点联通，问最少要修多长的公路。

题解： 对于q对数字，记他们间的距离为0。然后跑最小生成树即可。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>

using namespace std;

int const N = 5e2 + 10, M = 1e5 + 10;
int g[N][N], dis[N], st[N];
int n, m;

// prime算法
int prime() {
    memset(dis, 0x3f, sizeof dis);  // dis初始化
    memset(st, 0, sizeof st);
    int res = 0;  // 记录最小生成树的距离和
    for (int i = 0; i < n; ++i) {// 外循环n次
        int t = -1;  // 记录到集合最小的点
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dis[j] < dis[t]))
                t = j;  // 找到t
        if (i && dis[t] == 0x3f3f3f3f) return dis[t];  // 如果集合内有点且t点到集合的距离为无穷(即表示t不在连通图内)， 不存在最小生成树
        if (i) res += dis[t];  // 如果集合内有点，累加res
        for (int j = 1; j <= n; ++j)  // 更新所有与t连接的点
            dis[j] = min(dis[j], g[t][j]);
        st[t] = 1;  // 把t放入集合
    }
    return res;  // 返回res
}

int main() {
    freopen("in.txt", "r", stdin);
    while (scanf("%d%d", &n, &m) != EOF) {
        if (!n) break;
        memset(g, 0x3f, sizeof g);  // 初始化邻接矩阵
        for (int i = 0; i < m; ++i) {// 读入边信息
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            g[a][b] = g[b][a] = min(g[a][b], c);  // 无向图注意要赋值两次
        }
        cout << prime() << endl;
    }
    return 0;
}

ZOJ 1586 QS Network

题意： 最小生成树裸题

题解： 最小生成树裸题

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>

typedef long long LL;
using namespace std;

int const N = 1010, M = N * 2;
int g[N][N], dis[N], st[N], cost[N];
int n, m;

// prime算法
int prime() {
    memset(dis, 0x3f, sizeof dis);  // dis初始化
    memset(st, 0, sizeof st);
    int res = 0;  // 记录最小生成树的距离和
    for (int i = 0; i < n; ++i) {// 外循环n次
        int t = -1;  // 记录到集合最小的点
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dis[j] < dis[t]))
                t = j;  // 找到t
        if (i && dis[t] == 0x3f3f3f3f) return dis[t];  // 如果集合内有点且t点到集合的距离为无穷(即表示t不在连通图内)， 不存在最小生成树
        if (i) res += dis[t];  // 如果集合内有点，累加res
        for (int j = 1; j <= n; ++j)  // 更新所有与t连接的点
            dis[j] = min(dis[j], g[t][j]);
        st[t] = 1;  // 把t放入集合
    }
    return res;  // 返回res
}
int T;

int main() {
    cin >> T;
    while (T--) {
        cin >> n;
        memset(g, 0x3f, sizeof g);  // 初始化邻接矩阵
        for (int i = 1, t; i <= n; ++i) cin >> cost[i];
        for (int i = 1; i <= n; ++i) {
            for (int j = 1, t; j <= n; ++j) {
                cin >> t;
                g[i][j] = t + cost[i] + cost[j];
            }
        }
        cout << prime();
        if (T) cout << endl;
    }
    return 0;
}

POJ 1789 Truck History

题意： 给定n个字符串，每个字符串看作一个点，2个点间的距离为不同给定字符个数，球最小生成树。

题解： 裸题

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <climits>
#include <string>

using namespace std;

int const N = 2e3 + 10, M = 1e5 + 10;
int g[N][N], dis[N], st[N];
int n, m;
string s[N];

// prime算法
int prime() {
    memset(dis, 0x3f, sizeof dis);  // dis初始化
    memset(st, 0, sizeof st);
    int res = 0;  // 记录最小生成树的距离和
    for (int i = 0; i < n; ++i) {// 外循环n次
        int t = -1;  // 记录到集合最小的点
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dis[j] < dis[t]))
                t = j;  // 找到t
        if (i && dis[t] == 0x3f3f3f3f) return dis[t];  // 如果集合内有点且t点到集合的距离为无穷(即表示t不在连通图内)， 不存在最小生成树
        if (i) res += dis[t];  // 如果集合内有点，累加res
        for (int j = 1; j <= n; ++j)  // 更新所有与t连接的点
            dis[j] = min(dis[j], g[t][j]);
        st[t] = 1;  // 把t放入集合
    }
    return res;  // 返回res
}

int cal(int idx1, int idx2) {
    int res = 0;
    for (int i = 0; i < 7; ++i) res += (s[idx1][i] != s[idx2][i]);
    return res;
}

int main() {
    while(scanf("%d", &n) != EOF) {
        if (!n) break;
        memset(g, 0x3f, sizeof g);  // 初始化邻接矩阵
        for (int i = 1; i <= n; ++i) cin >> s[i];
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                g[i][j] = g[j][i] = cal(i, j);
            }
        }
        printf("The highest possible quality is 1/%d.\n", prime());
    }
    return 0;
}

POJ 2349 Arctic Network

题意： 北极的某区域共有 n 座村庄，每座村庄的坐标用一对整数 (x,y) 表示。为了加强联系，决定在村庄之间建立通讯网络，使每两座村庄之间都可以直接或间接通讯。通讯工具可以是无线电收发机，也可以是卫星设备。无线电收发机有多种不同型号，不同型号的无线电收发机有一个不同的参数 d，两座村庄之间的距离如果不超过 d，就可以用该型号的无线电收发机直接通讯，d 值越大的型号价格越贵。现在要先选择某一种型号的无线电收发机，然后统一给所有村庄配备，数量不限，但型号都是相同的。配备卫星设备的两座村庄无论相距多远都可以直接通讯，但卫星设备是有限的，只能给一部分村庄配备。现在有 k 台卫星设备，请你编一个程序，计算出应该如何分配这 k 台卫星设备，才能使所配备的无线电收发机的 d 值最小。
题解： 把本题翻译过来就是求给定一个d，删去图中权值大于d的所有边，做最小生成树，得到的连通块数目要求小于等于k，求这么个d
通常的思路是二分d，然后求连通块个数，判断连通块个数和k的关系
但是kruskal具有单调性，枚举的边从小到大，集合的数目从大到小，具有单调性，因此不需要二分，只需要每次枚举完判断一下当前的集合个数是否等于k，如果等于k，那么说明当前放入的这条边的权值就是d。

代码： poj一直没编译过，放在其他平台交的

#include<bits/stdc++.h>

using namespace std;

typedef pair<double, double> PDD;
unordered_map<int, PDD> grid;
int n, k, cnt, m;
int const N = 5e2 + 10, M = N * N;
int fa[N];
struct Edge {
    int a, b;
    double w;

    bool operator< (const Edge &W) {
        return w < W.w;
    }
}edge[M];

int get(int x) {
    if (x == fa[x]) return x;
    return fa[x] = get(fa[x]);
}

void kruskal() {
    for (int i = 1; i <= cnt; ++i) fa[i] = i;

    int cnt_con = cnt;  // 记录连通块个数
    if (cnt_con < k) {
        cout << 0.00 << endl;
        return;
    }

    // 从小到大枚举边
    sort(edge, edge + m);
    for (int i = 0; i < m; ++i) {
        int a = edge[i].a, b = edge[i].b;
        double w = edge[i].w;

        int pa = get(a), pb = get(b);
        if (pa != pb) {
            fa[pa] = pb;
            cnt_con--;  // 每次加入边后，如果两个端点不在一个连通块内，那么合并后连通块个数将会减一
        }

        if (cnt_con == k) { // 一旦减到k，说明当前的边权值即为d
            printf("%.2lf", w);
            return;
        }
    }
}

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

    // 给每个节点标号
    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        grid[++cnt] = {x, y};
    }

    // 计算每个节点间的距离
    for (int i = 1; i <= cnt; ++i)
        for (int j = 1; j <= cnt; ++j) {
            int dx = grid[i].first - grid[j].first, dy = grid[i].second - grid[j].second;
            edge[m++] = {i, j, sqrt(dx * dx + dy * dy)};
        }

    // 做最小生成树
    kruskal();
    return 0;
}

POJ 1751 Highways

题意： 给定n个村庄的坐标，需要使得这n个村庄联通。给定m条路，表示a村庄和b村庄联通，不需要修路。现在问要把所有村庄联通需要的最少花费为多少。

题解： 欧氏距离计算花费，对于已经修过的，那么花费为0.

代码： 和前面一个题目基本一样，没啥意思，不写了，贴上大佬的代码：https://www.cnblogs.com/alihenaixiao/p/4547542.html

#include <cmath>
#include <string>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int maxn = 760;
const int INF = 0x3f3f3f3f;
const double Exp = 1e-10;
int cost[maxn][maxn], lowc[maxn];
int vis[maxn], pre[maxn];
//pre[i]记录i的前驱
struct point
{
    int x, y;
};

int length (point a, point b)
{
    return (a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y);
}
void prim (int n)
{
    int i, j;
    memset (vis, 0, sizeof(vis));
    vis[1] = 1;
    for (i=1; i<=n; i++)
    {
        pre[i] = 1;
        lowc[i] = cost[1][i];
    }

    for (i=1; i<n; i++)
    {
        int p;
        int mini = INF;
        for (j=1; j<=n; j++)
            if (!vis[j] && mini > lowc[j])
            {
                p = j;
                mini = lowc[j];
            }
        if (cost[p][pre[p]] != 0)//需要建路
            printf ("%d %d\n", pre[p], p);
        vis[p] = 1;
        for (j=1; j<=n; j++)
        {
            if (!vis[j] && lowc[j] > cost[p][j])
            {
                lowc[j] = cost[p][j];
                pre[j] = p;
            }
        }
    }
}

int main ()
{
    int n;
    point p[maxn];
    scanf ("%d", &n);
    for (int i=1; i<=n; i++)
    {
        scanf ("%d %d", &p[i].x, &p[i].y);
        for (int j=1; j<i; j++)
            cost[i][j] = cost[j][i] = length(p[i], p[j]);
        cost[i][i] = 0;
    }

    int m;
    scanf ("%d", &m);
    while (m --)
    {//把已经建过路的点聚集在一起
        int x, y;
        scanf ("%d %d", &x, &y);
        cost[x][y] = cost[y][x] = 0;
    }
    prim(n);
    return 0;
}

POJ 1258 Agri-Net

题意： 完全裸题，直接看别人的代码把：https://blog.csdn.net/versionwen/article/details/99686746

题解：

代码：

POJ 3026 Borg Maze

题意： 直接看别人题解吧，比较裸题：https://blog.csdn.net/qq_40421671/article/details/83041978

题解：

代码：

POJ 1679 The Unique MST

题意： 判断一个最小生成树是否唯一

题解： 先预处理一遍，求出最小生成树上的边，然后暴力枚举这些边，删除之后再跑一遍最小生成树，看是否和原来一样。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;
typedef long long LL;
LL n, m;
LL const N = 1000 + 10;
struct E {
    LL u, v;
    LL w;
}edge[N*N];

bool cmp(struct E a, struct E b) {
    return a.w < b.w;
}
LL p[N*N], st[N*N];
vector<LL> used;

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

// kruskal算法
LL kruskal(LL cn) {
    LL res = 0;
    LL cnt = 0;  // res记录最小生成树的权值，cnt记录当前最小生成树内有几条边
    for (LL i = 1; i <= n; ++i) p[i] = i;  // 并查集初始化
    for (LL i = 0; i < m ; ++i) {// 枚举每一条边
        if (cn==i) continue;
        LL a = edge[i].u, b = edge[i].v;
        LL c = edge[i].w;  // 边a, b, 权值为c
        a = find(a), b = find(b);  // 得到a的父节点和b的父节点
        if (a != b) {// 判断a和b是否在同一个集合内
            res += c;  // 在的话放入集合内
            if (cn == -1) used.push_back(i);
            cnt++;
            p[a] = b;
        }
    }
    if (cnt < n-1) return -1;
    else return res;
}
LL T;

int main() {
    cin >> T;
    while(T--) {
        used.clear();
        cin >> n >> m;
        for (LL i = 0, a, b, c; i < m; ++i) {
            scanf("%lld%lld%lld", &edge[i].u, &edge[i].v, &edge[i].w);
           /* E tmp;
            tmp.u = a, tmp.v = b, tmp.w = c;
            edge[i] = tmp;
            */
        }
        sort(edge , edge +  m, cmp);
        LL mst = kruskal(-1);  // 最早的最小生成树

        LL flg = 0;
        for (LL i = 0; i < used.size(); ++i) {  // 暴力枚举删除的边
         
            LL idx = used[i];  // 边的下标
           
            LL new_mst = kruskal(idx);
            if (new_mst == mst) {  
                flg = 1;
                break;
            }
        }
        if (flg) cout << "Not Unique!\n";
        else cout << mst << endl;
    }
    return 0;
}

HDU 1233 还是畅通工程

题意： 裸题

题解：

代码：

HDU 1301 Jungle Roads

题意： 裸题

题解：

代码：

HDU 1875 畅通工程再续

题意： 裸题

题解：

代码：

「已注销」
关注
专栏目录
最小生成树
梦醒了
01-23 336
例题一：http://acm.hdu.edu.cn/showproblem.php?pid=1879 AC代码： #include//c++ #include//数学公式 #include//malloc #include #include #include//输入输出 #include//快排 #include//队列 #include//优先队列 #include//栈 #include/
POJ2349 最小生成树（Prim更适合稠密图）
他的博客
08-03 1292
0 题意很简单，要求每个站点之间都要可以直接或者间接联系到，但是联系方式有两种，近距离的用无线（每个站点都有），远距离的用卫星（部分站点有卫星，且当两个站点都有卫星才可以用卫星直接联系），给出卫星站点数量，要求输出最大的两个无线站点之间的距离。 1 读完题意很容易想到最小生成树，但是卫星站点应该放到哪里？是先把距离最远的几个站点分配为卫星站点，再用Prim；还是先用Prim再将最小生
POJ2349&ZOJ1914--Arctic Network【最小生成树】
阳光照耀圣西罗
08-04 875
链接：http://poj.org/problem?id=2349 题意：北极有一些村庄，现需要在这些村庄间建立起通讯，有s个卫星频道，任何两个拥有卫星频道的村庄都可以直接通过卫星进行通讯而无视距离，没有卫星的村庄通过无线电进行通讯，并且这两个村庄的距离不能超过D，D值取决于无线电收发器的功率，功率越大，D值越大，但价格也越高，出于购买费用和维护费用的考虑，所有村庄的无线电收发器都相同，即D值相
[kuangbin带你飞]专题六 最小生成树 题解+总结
放荡者的茶会
10-06 1860
kuangbin带你飞：点击进入新世界 最短路算法模板：点击进入新世界 总结： 本人算是初学者中的初学者，欢迎交流~ kuangbin的专题确实是理解最短路的一大途径，这篇博客主要记录题解，顺便总结最短路的题型。 A.模板题 参考1 . 6 . 10 B.变形最短路 （求最大边权的最小值or最小边权的最大值） 参考2 . 3 C.变形最短路 （求往返最短路的最大值） 参考4 D....
kuangbin专题六 最小生成树题解
ChaningLou的博客
03-02 381
kuangbin专题六 最小生成树 A. A Jungle Roads POJ - 1251（节点编号处理） 模板题，把字符经过 - 'A' + 1 处理为从1开始的节点编号。稠密无向图，用邻接矩阵存，对称地存储最小的距离（以防有重边）。套用prim()模板 #include <iostream> #include <cstring> #include <algorithm> using namespace std; const int N = 30; const int
[kuangbin带你飞]专题六 最小生成树A
zjy2015302395的博客
01-05 372
http://poj.org/problem?id=1251题意：题目大意在相通n个岛屿的所有桥都坏了，要重修，重修每一个桥所用的时间不同，求重修使每个岛屿都间接或直接与其他岛屿相同时所用的的最短时间（只有修完一个桥后才可修下一个桥）。 对于数据，数据输入的第一行n代表岛屿的个数，当为0是结束程序，接着n-1行开始时为这岛屿的编号，用大写字母表示，接着是一个整数m，表示与该岛屿连接的字典序大于该岛
[kuangbin带你飞]专题六 最小生成树
Mosu_的专栏
08-07 475
A - Jungle Roads 题目链接 #include #include #include #include using namespace std; const int INF=0x3f3f3f3f; const int MAXN=30; bool vis[MAXN]; int lowc[MAXN]; int cost[MAXN][MAXN]; int Prim(int n
kuangbin专题六 最小生成树 题解
qq_37804582的博客
10-22 229
kuangbin专题六 最小生成树 题解 最小生成树总结 自从学习了最小生成树，就感觉这是图论里面最简单的题目了吧！！！难点在于如何分析题目是一道最小生成树题，然后再构建图 求最小生成树有三种算法：Kruskal、Prim和Boruvka。在我做过的题目中基本都是用前两种算法做的，最后一种基本没用。 Kruskal算法的基本思想是以变为主导地位，始终都是选择当前可用...
[kuangbin]专题六 最小生成树
00后的博客
03-28 169
POJ 1251 Jungle Roads POJ 1287 Networking POJ 2031 Building a Space Station POJ 2421 Constructing Roads ZOJ 1586 QS Network POJ 1789 Truck History POJ 2349 Arctic Network POJ 1751 Highways POJ 1258 Agri-Net POJ 3026 Borg Maze POJ 1679 The Unique MST HDU 12
[宫水三叶的刷题日记]：（图论）最小生成树1
08-03
《宫水三叶的刷题日记》系列主要探讨的是图论中的一个重要概念——最小生成树。最小生成树问题是在加权无向图中找到一棵包括所有顶点的树，使得树的所有边的权重之和尽可能小。在这个专题中，作者通过一系列的题目，...
（专题）最小生成树
jerans的博客
11-30 355
最小生成树 ： kruskal和prim 注意理解prim和dijikstra的区别：prim每次找离已生成的集合最近的点，后者是找离原点最近的点 Borg Maze Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 13547   Accepted:
【图论专题】最小生成树及其简单应用
繁凡さん的博客
07-18 1542
题目列表： 题目 算法 AcWing 1140. 最短网络 prim模板 AcWing 1141. 局域网 kruskal模板 AcWing 1142. 繁忙的都市 瓶颈MST（最大边权最小的生成树） AcWing 1143. 联络员 确定边最小生成树 AcWing 1144. 连接格点 确定边最小生成树、搜索建图 UVA1395 苗条的生成树 Slim Span 瓶颈MST 最短路算法 A、AcWing 1140. 最短网络（prim模板） #include&l
图算法专题（三）【最小生成树】
苣篛
05-08 885
最小生成树最小生成树及其性质性质：prim算法基本思想 最小生成树及其性质   最小生成树（MST）是在一个给定的无向图G(V,E)中求一棵树T，使得这棵树拥有图G中的所有顶点，且所有边都是来自图G中的边，并且满足整棵树的边权之和最小。 性质： 最小生成树的边数=顶点数-1，且树内没有环。 对给定的图G(V,E)，其最小生成树可以不唯一，但是其边权之和一定是唯一的。 最小生成树的根节点可以是这棵...
5253-微信小程序基于springboot汽车维修管理系统微信小程序springboot（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
基于Matlab界面GUI设计的身份证号码识别源码[Matlab界面GUI设计].zip
09-15
基于
1.开源数据库MySQL DBA运维实战 第1章 部署.学习笔记整理分享给需要的同学
最新发布
09-15
1.开源数据库MySQL DBA运维实战 第1章 部署.学习笔记整理分享给需要的同学
java写s7和plc通讯
09-15
java写s7和plc通讯
基于 Flask 的书评系统.zip
09-15
这是一个基于 Flask 框架的书评系统项目。用户可以通过注册登录系统，对书籍进行搜索、发表评论以及查看其他用户的评论。项目利用 Goodreads 的第三方 API，引入更广泛的读者评分。此外，用户还可以通过应用程序的 API 以编程方式查询书籍详情和书评。项目具有注册、登录、注销、书籍导入、搜索、书籍页面展示、评论提交、Goodreads 评级数据展示和 aPI 访问等功能。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看ReadME.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
深度解析：生成树算法与最小生成树
最小生成树（Minimum Spanning Tree, MST）是带权重的无向图中一个特别重要的概念。MST是图中所有边的权重之和最小的生成树。这通常用于网络设计，例如最小成本的通信网络或最低造价的基础设施建设。在带权重的有向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值