kruskal算法：POJ No.3723 Conscription_最小生成树应用_最大权森林

 #define _CRT_SECURE_NO_WARNINGS
 /*
  5 5 8
  4 3 6831
  1 3 4583
  0 0 6592
  0 1 3063
  3 3 4975
  1 3 2049
  4 2 2104
  2 2 781
 */
 #include <iostream>
 #include <vector>
 #include <algorithm>
 #include <cstdio>
 using namespace std;

 const int maxn =  + ;
 const int maxR = ;
 const int INF = ;
 int par[maxn];     //父亲,  当par[x] = x时,x是所在的树的根
 int Rank[maxn];    //树的高度
 int N, M, R;
 int V, E;
 int x[maxR], y[maxR], d[maxR];

 struct edge
 {
     int u, v, cost;
     edge(int u = , int v = , int cost = ) : u(u), v(v), cost(cost) {}
 };

 bool comp(const edge& e1, const edge& e2) {
     return e1.cost < e2.cost;
 }

 edge es[maxn];

 //并查集实现-高效的判断是否属于同一个连通分量。
 void init_union_find(int n);
 int find(int x);
 void unite(int x, int y);
 bool same(int x, int y);

 //最小生成树
 void input();
 int kruskal();   //最小生成树算法
 //最大权森林
 void solve();

 //初始化n个元素
 void init_union_find(int n)
 {
     for (int i = ; i < n; i++) {
         par[i] = i;
         Rank[i] = ;
     }
 }

 //查询树的根
 int find(int x) {
     if (par[x] == x) {
         return x;
     }
     else {
         return par[x] = find(par[x]);
     }
 }

 //合并x和y所属集合
 void unite(int x, int y) {
     x = find(x);
     y = find(y);
     if (x == y) return;

     if (Rank[x] < Rank[y]) {
         par[x] = y;
     }
     else {
         par[y] = x;
         if (Rank[x] == Rank[y]) Rank[x]++;    //如果x,y的树高相同,就让x的树高+1
     }
 }

 //判断x和y是否属于同一个集合
 bool same(int x, int y) {
     return find(x) == find(y);
 }

 void input()
 {
     scanf("%d%d%d", &N, &M, &R);
     for (int i = ; i < R; i++) {
         scanf("%d%d%d", &x[i], &y[i], &d[i]);
     }
 }

 int kruskal()
 {
     sort(es, es + E, comp); //按照edge.cost的顺序从小到大排序
     init_union_find(V);     //将并查集初始化
     int res = ;
     for (int i = ; i < E; i++) {
         edge e = es[i];
         if (!same(e.u, e.v)) {
             unite(e.u, e.v);
             res += e.cost;
         }
     }
     return res;
 }

 void solve()
 {
     V = N + M;
     E = R;
     for (int i = ; i < R; i++) {
         es[i] = edge(x[i], N + y[i], -d[i]);
     }
     int res = kruskal();
     //cout << "Debug" << res << endl;
     cout <<  * (N + M) + res << endl;  //kruskal结果是-d[i]
 }

 int main()
 {
     input();
     solve();
     return ;
 }