题九：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表示已连接

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

思路：
这个问题可以使用最小生成树算法（如Prim算法或Kruskal算法）来解决。在这个问题中，基站可以看作是图的顶点，光纤可以看作是图的边，光纤的成本可以看作是边的权重。已经存在的光纤可以看作是权重为0的边。我们的目标是找到一个最小生成树，即一个包含所有顶点且边的权重之和最小的树。

import java.util.*;
public class Main {
      // 并查集数组
      static int[] parent;
      // 并查集查找函数，用于查找x所在的集合
      static int find(int x) {
         // 如果x不是自己的父节点，那么就让x的父节点为x的父节点的父节点（路径压缩）
          if (parent[x] != x) {
              parent[x] = find(parent[x]);
          }
          // 返回x的父节点
          return parent[x];
      }
      // 定义边的类
      static class Edge {
          int u, v, cost, pre;

          // 构造函数
          public Edge(int u, int v, int cost, int pre) {
              this.u = u; // 基站u
              this.v = v; // 基站v
              this.cost = cost; // 架设光纤的成本
              this.pre = pre; // 是否已存在光纤连接
          }
      }      
   // 并查集合并函数，用于合并x和y所在的集合
   static void union(int x, int y) {
       int rootX = find(x); 
       // 找到x的根节点       
       int rootY = find(y); 
      // 找到y的根节点       
      // 如果x和y的根节点不同，那么就将x的根节点的父节点设为y的根节点
       if (rootX != rootY) {
           parent[rootX] = rootY;
       }
   }
 public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       int N = scanner.nextInt();// 基站的个数
       int M = scanner.nextInt();// 具备光纤直连条件的基站对的数目
       parent = new int[N + 1];// 初始化并查集数组
       for (int i = 1; i <= N; i++) {
           parent[i] = i;// 初始时每个节点的父节点就是自己
       }
       List<Edge> edges = new ArrayList<>(); // 存储所有的边
       for (int i = 0; i < M; i++) {
           int X = scanner.nextInt(); // 基站X
           int Y = scanner.nextInt(); // 基站Y
           int Z = scanner.nextInt(); // 架设光纤的成本
           int P = scanner.nextInt(); // 是否已存在光纤连接
           edges.add(new Edge(X, Y, Z, P)); // 添加边
           if (P == 1) { // 如果已存在光纤连接，那么就将X和Y合并
               union(X, Y);
           }
       }
       // 将所有的边按照成本从小到大排序
       edges.sort((a, b) -> a.cost - b.cost);
       int cost = 0; // 总的成本
       // 遍历所有的边
       for (Edge edge : edges) {
           // 如果边的两个端点不在同一个集合中，那么就将这条边添加到最小生成树中
           if (find(edge.u) != find(edge.v)) {
               cost += edge.cost; // 累加成本
               union(edge.u, edge.v); // 合并边的两个端点所在的集合
           }
       }
       // 检查所有的基站是否都在同一个集合中
      for (int i = 2; i <= N; i++) {
           // 如果有基站不在同一个集合中，那么就输出-1并结束程序
           if (find(i) != find(1)) {
               System.out.println(-1);
               return;
           }
       }
       // 输出总的成本
       System.out.println(cost);
   }
 }