MST:Conscription(POJ 3723)

　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　 　男女搭配，干活不累

　　题目大意：需要招募女兵和男兵，每一个人都的需要花费1W元的招募费用，但是如果有一些人之间有亲密的关系，那么就会减少一定的价钱，如果给出1~9999的人之间的亲密关系，现在要你求招募所有人的时候，最少的价格？

　　看似这一题要用到二分图，其实根本用不上，我们仔细想一下我们如果把所有的男和女都看成人的话，那么其实我们就是要求这些关系的最大值的负值（也就是最小生成树）

　　这样一看，这题其实很裸，要注意区分男和女就行（别搞错男女了，不然就RE了），男的点的位置就看成是女的总数+男的坐标就可以了额

　　

 #include <iostream>
 #include <functional>
 #include <algorithm>
 #define MAX 20005
 #define MAX_E 50005

 using namespace std;
 typedef int Position;
 typedef struct _edge
 {
     int cost;
     int from;
     Position to;
 }Edge_Set;
 int fcomp(const void *a, const void *b)
 {
     return (*(Edge_Set *)a).cost - (*(Edge_Set *)b).cost;
 }

 static Edge_Set Edge[MAX_E];
 Position V_Set[MAX];

 void Kruskal(const int, const int);
 Position Find(Position);
 bool If_Same(Position, Position);
 void Union(Position, Position);

 int main(void)
 {
     int test_case, men_sum, women_sum, R_sum, cost_tmp;
     Position from, to;
     scanf("%d", &test_case);

     while (test_case--)
     {
         //这一题不用二分图的方法，直接上MST
         scanf("%d%d%d", &women_sum, &men_sum, &R_sum);
         for (int i = ; i < R_sum; i++)
         {
             scanf("%d%d%d", &from, &to, &cost_tmp);//男生的坐标要加上女生总数
             Edge[i].from = from; Edge[i].to = to + women_sum; Edge[i].cost = -cost_tmp;//存负的
         }
         Kruskal(men_sum + women_sum, R_sum);
     }
     return ;
 }

 Position Find(Position x)
 {
     if (V_Set[x] < )
         return x;
     else return V_Set[x] = Find(V_Set[x]);
 }

 bool If_Same(Position x, Position y)
 {
     Position px, py;
     px = Find(x); py = Find(y);
     return px == py;
 }

 void Union(Position x, Position y)
 {
     Position px, py;
     px = Find(x); py = Find(y);

     if (px != py)
     {
         if (V_Set[px] < V_Set[py])
         {
             V_Set[px] += V_Set[py];
             V_Set[py] = px;
         }
         else
         {
             V_Set[py] += V_Set[px];
             V_Set[px] = py;
         }
     }
 }

 void Kruskal(const int n, const int edge_sum)
 {
     //初始化查并集
     fill(V_Set, V_Set + n, -);
     qsort(Edge, edge_sum, sizeof(Edge_Set), fcomp);//把边排个大小

     Edge_Set e;
     long long ans = ;
     for (int i = ; i < edge_sum; i++)
     {
         e = Edge[i];
         if (!If_Same(e.from, e.to))
         {
             Union(e.from, e.to);
             ans += e.cost;
         }
     }
     printf("%lld\n", (long long)n *  + ans);
 }