【OD机试题解法笔记】5G网络建设

题目

需要在某城市进行 5G
网络建设，已经选取N个地点设置5G基站，编号固定为1到N，接下来需要各个基站之间使用光纤进行连接以确保基站能互联互通，不同基站之间假设光
纤的成本各不相同，且有些节点之间已经存在光纤相连。
请你设计算法，计算出能联通这些基站的最小成本是多少。
注意：基站的联通具有传递性，比如基站A与基站B架设了光纤，基站B与基站C也架设了光纤，则基站A与基站C视为可以互相联通。

输入描述
第一行输入表示基站的个数N，其中：
0 < N ≤ 20
第二行输入表示具备光纤直连条件的基站对的数目M，其中：
0 < M < N * (N - 1) / 2
从第三行开始连续输入M行数据，格式为
X Y Z P

其中：
X，Y 表示基站的编号
0 < X ≤ N
0 < Y ≤ N
X ≠ Y
Z 表示在 X、Y之间架设光纤的成本
0 < Z < 100
P 表示是否已存在光纤连接，0 表示未连接，1表示已连接

输出描述
如果给定条件，可以建设成功互联互通的5G网络，则输出最小的建设成本
如果给定条件，无法建设成功互联互通的5G网络，则输出 -1

用例

输入	输出	说明
3 3 1 2 3 0 1 3 1 0 2 3 5 0	4	只需要在1，2以及1，3基站之间铺设光纤，其成本为3+1=4
3 1 1 2 5 0	-1	3基站无法与其他基站连接，输出-1
3 3 1 2 3 0 1 3 1 0 2 3 5 1	1	2，3基站已有光纤相连，只要在1，3基站之间铺设光纤，其成本为1

思考

        基站看成图中的节点，基站之间的铺设光纤成本看成是节点之间的权重，目标是把这些节点连起来形成的树总成本最低，总成本是累加连通的2个节点之间的权重，忽略已连接的节点之间权重。考察的是最小生成树相关算法。

        最小生成树（Minimum Spanning Tree, MST）是图论中的经典问题，用于在连通无向图中找到一棵包含所有顶点的树，且树中所有边的权重之和最小。最小生成树算法有Kruskal 算法、Prim 算法、Boruvka 算法，下面是基本对比：

算法	思想	数据结构	时间复杂度	适用场景
Kruskal	贪心	并查集 + 排序	\(O(E \log E)\)	稀疏图、离线处理
Prim	贪心	优先队列 / 邻接矩阵	\(O(E \log V)\)/\(O(V^2)\)	稠密图、从特定点开始
Boruvka	并行贪心	并查集 + 最小边表	\(O(E \log V)\)	并行计算、大规模图

选择建议：

• 稀疏图（如社交网络、地理网络）：优先选 Kruskal 算法（并查集高效）或 Prim 算法（优先队列优化）。
• 稠密图（如全连接图）：选 Prim 算法（邻接矩阵），时间复杂度更优。
• 并行计算场景：选 Boruvka 算法。

本题用实现起来最简单的Kruskal算法就行了。

Kruskal 算法

核心思想

基于贪心算法，按边权从小到大排序，依次选择边，若该边连接的两个顶点不在同一连通分量中，则加入生成树，直到所有顶点连通。

算法步骤

1. 排序：将图中所有边按权重从小到大排序。
2. 初始化并查集：每个顶点初始化为独立的连通分量。
3. 遍历边：依次检查每条边，若边的两个顶点属于不同连通分量：
   • 将该边加入最小生成树。
   • 合并两个顶点所在的连通分量。
4. 终止条件：当生成树包含 \(n-1\) 条边（n 为顶点数）时结束。

时间复杂度

• 排序边的时间：\(O(E \log E)\)（E 为边数）。
• 并查集操作时间：\(O(E \alpha(V))\)，\(\alpha\) 为阿克曼函数的反函数，近似常数。
• 总复杂度：\(O(E \log E)\)，适用于边稀疏的图（如邻接表存储）。

适用场景

• 稀疏图（边数较少）。
• 需要高效判断连通性的场景（并查集优势明显）。

参考代码一（并查集）

class UnionFindSet {

    constructor(n) {
        this.parents = new Array(n+1).fill(0);
        this.parents.forEach((_, i) => {
            this.parents[i] = i;
        });       
    }

    union(u, v) {
        let rootU = this.find(u);
        let rootV = this.find(v);
        if (rootU === rootV) return false;
        this.parents[rootU] = rootV;
        return true;
    }

    find(u) {
        while(this.parents[u] !== u) {
            this.parents[u] = this.parents[this.parents[u]];
            u = this.parents[u];
        }
        return u;
    }

}


function solution(line) {
    let arr = line.trim().split('\n');
    const N = Number(arr[0].trim());
    const M = Number(arr[1].trim());
    const data = arr.slice(2);

    const edges = [];
    for (let i = 0; i < M; i++) {
        const [u, v, z, p] = data[i].split(' ').map(e => parseInt(e));
        edges.push({ cost: p === 1 ? 0: z, u, v });
    }

    // console.log(edges);
    edges.sort((a, b) => a.cost - b.cost);

    const uf = new UnionFindSet(N);

    let totalCost = 0;
    let edgeCount = 0;

    for (const { cost, u, v } of edges) {
        if (uf.union(u, v)) {
            totalCost += cost;
            edgeCount++;
            if (edgeCount === N-1) {
                break;
            }
        }
    }

    if (edgeCount === N - 1) {
       console.log(totalCost);
    } else {
       console.log(-1);  
    }
}



const lines = [
`3
3
1 2 3 0
1 3 1 0
2 3 5 0`,
`3
1
1 2 5 0`,
`3
3
1 2 3 0
1 3 1 0
2 3 5 1`
];

lines.forEach(line => {
    solution(line);
});

参考代码二（Prim算法）

function solution() {
   const N = Number(readline());
   const M = Number(readline());

   const graph = Array.from({length: N + 1}, () => []);

   for (let i = 0; i < M; i++) {
       const [x, y, z, p] = readline().split(' ').map(Number);
       const cost = p === 1 ? 0 : z;
       graph[x].push([y, cost]);
       graph[y].push([x, cost]);
   }
   
   const inMST = Array(N + 1).fill(false);
   let totalCost = 0;
   inMST[1] = true;

   for (let step = 0; step < N - 1; step++) {
       let minCost = Infinity;
       let nextNode = -1;

       for (let u = 1; u <= N; u++) {
          if (!inMST[u]) continue;
          for (const [v, cost] of graph[u]) {
              if (!inMST[v] && cost < minCost) {
                 minCost = cost;
                 nextNode = v;
              }
          }
       }

       if (nextNode === -1) {
           console.log(-1);
           return;
       }

       inMST[nextNode] = true;
       totalCost += minCost;
   }
   
   console.log(totalCost);
}



// 测试用例
const cases = [
    `3
3
1 2 3 0
1 3 1 0
2 3 5 0`, // 输出4
    `3
1
1 2 5 0`, // 输出-1
    `3
3
1 2 3 0
1 3 1 0
2 3 5 1`  // 输出1
];

let caseIndex = 0;
let lineIndex = 0;
const readline = (() => {
    let lines = [];
    return () => {
        if (!lineIndex) lines = cases[caseIndex].trim().split('\n').map(l => l.trim());
        return lines[lineIndex++];
    };
})();

cases.forEach((_, i) => {
    caseIndex = i;
    lineIndex = 0;
    solution();
});