通信网络设计

假设你是电信工程师，需要为村庄间架设通信网络，使任何两个村庄间都可以实现通信连通（但不一定有直接的快速线路相连，只要互相间接有线路连通即可）。现有规划信息数据，列出了所有可能架设线路的两个村庄及其线路成本，请判断是否可以实现村村互联，如果可以，整个网络的最低成本是多少？如果不能实现村村互联，分成几个部分，各部分有哪些村庄？

输入格式:

第一行给出村庄数目n (1≤n≤50)和候选线路条数m≥0；随后的m行，每行给出3个正整数，分别是该条线路直接连通的两个村庄的编号（编号从1开始起编）以及该线路的建设成本。

输出格式:

输出是否实现村村互联的判断结果。
如果是，再输出整个网络的最低成本。
如果不能实现互联，输出分成几部分，每部分有哪些村庄。每个不连通部分的中的顶点是从小到大 。各部分的前后顺序也是按第一个顶点从小到大列出。

输入样例:

在这里给出一组输入。例如：

6 10
1 2 6
1 5 10
1 6 12
2 4 5
2 6 8
2 3 3
3 4 7
4 5 9
4 6 11
5 6 16

输出样例:

在这里给出相应的输出。例如：

YES!
Total cost:31

输入样例2:

在这里给出一组输入。例如：

5 4
1 2 3
1 3 11
2 3 8
4 5 9

输出样例2:

在这里给出相应的输出。例如：

NO!
1 part:1 2 3
2 part:4 5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

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

const int N = 100010;
int m, n, ans = 0;
bool st[N]; // 标记数组，用于标记是否访问过某个节点
struct Edge {
    int u, v, w; // 边的起点、终点和权值
};
vector<Edge> g; // 存储图的边集合
int p[N]; // 并查集数组，用于存储节点的祖先节点

// 并查集的查找操作
int find(int n) {
    if (n != p[n]) return find(p[n]); // 递归查找祖先节点
    return p[n];
}

// 比较函数，用于对边进行排序
bool cmp(Edge x, Edge y) {
    return x.w < y.w; // 按边的权值升序排序
}

// Kruskal算法实现最小生成树
void Kruskal() {
    for (int i = 0; i < g.size(); i++) { // 遍历边集合
        int a = g[i].u, b = g[i].v, c = g[i].w; // 获取当前边的起点、终点和权值
        a = find(a); // 查找起点的祖先节点
        b = find(b); // 查找终点的祖先节点
        if (a != b) { // 如果起点和终点不在同一个集合中
            p[a] = b; // 将起点所在集合的根节点设为终点所在集合的根节点
            ans += c; // 更新最小生成树的权值之和
        }
    }
}

int main() {
    cin >> n >> m; // 输入节点数和边数
    for (int i = 1; i <= n; i++) p[i] = i; // 初始化并查集数组，每个节点的祖先节点为自己
    for (int i = 0; i < m; i++) { // 输入边的信息
        int a, b, c;
        cin >> a >> b >> c;
        g.push_back((Edge){a, b, c}); // 将边加入边集合
    }
    sort(g.begin(), g.end(), cmp); // 对边集合按权值升序排序
    Kruskal(); // 执行Kruskal算法构建最小生成树
    bool flag = false; // 标志位，用于判断是否有未连接的节点
    for (int i = 1; i <= n; i++) { // 遍历所有节点
        if (find(1) != find(i)) { // 如果有节点不与起点1连通
            flag = true; // 设置标志位为true
            break; // 结束遍历
        }
    }
    vector<int> v; // 存储未连通节点的集合
    int con = 1; // 记录连通分量的编号
    if (!flag) { // 如果所有节点都连通
        cout << "YES!" << endl; // 输出YES
        cout << "Total cost:" << ans << endl; // 输出最小生成树的总权值
    } else { // 如果存在未连通的节点
        cout << "NO!" << endl; // 输出NO
        for (int i = 1; i <= n; i++) { // 遍历所有节点
            if (!st[i]) { // 如果当前节点未被访问过
                if (i != 1) cout << endl; // 如果不是第一个连通分量，输出换行符
                v.push_back(i); // 将当前节点加入未连通节点集合
                st[i] = true; // 将当前节点标记为已访问
                for (int j = i + 1; j <= n; j++) { // 遍历剩余节点
                    if (!st[j]) { // 如果当前节点未被访问过
                        if (find(i) == find(j)) { // 如果两个节点连通
                            v.push_back(j); // 将当前节点加入未连通节点集合
                            st[j] = true; // 将当前节点标记为已访问
                        }
                    }
                }
                cout << con << " part:"; // 输出当前连通分量的编号
                for (int j = 0; j < v.size() - 1; j++) { // 输出当前连通分量的节点
                    cout << v[j] << " ";
                }
                cout << v.back(); // 输出最后一个节点
                v.clear(); // 清空未连通节点集合
                con++; // 连通分量编号加1
            }
        }
    }
    return 0;
}