BZOJ 1196 [HNOI2006]公路修建问题：二分 + 贪心生成树check（类似kruskal）

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1196

题意：

　　n个城市，m对城市之间可以修公路。

　　公路有两种，一级公路和二级公路，在第i对城市之间修的花费分别为c1[i],c2[i]。

　　你需要修n-1条公路，连接起所有城市（一棵树），并且至少有k条一级公路。

　　问你“花费最大的一条公路”的最小花费（最大值最小）。

题解：

　　O(log(c))二分 * O(m)生成树check + O(mlog(m))预先将边排序

　　二分：

　　　　二分答案（可能的最大一条公路的花费）。

　　

　　check：

　　　　现在二分的值为now，要求所有边的花费 <= now.

　　　　所以贪心下：

　　　　　　对于每条边，只要不超过now，并且属于不同集合：能修一级就修一级，不行再修二级，然后加入生成树中。

　　　　　　并且还要先考虑最有可能可以修一级公路的边，所以预先将所有边按c1从小到大排序。

　　　　　　整个过程类似kruskal。。。

　　　　最后如果是一棵树(cnt==n-1)，并且一级公路数量足够(super>=k)，则答案可行。

AC Code:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <vector>
 #define MAX_N 10005
 #define COST_MAX 30005

 using namespace std;

 struct Edge
 {
     int sour;
     int dest;
     int fst;
     int sec;
     Edge(int _sour,int _dest,int _fst,int _sec)
     {
         sour=_sour;
         dest=_dest;
         fst=_fst;
         sec=_sec;
     }
     Edge(){}
     friend bool operator < (const Edge &a,const Edge &b)
     {
         return a.fst<b.fst;
     }
 };

 int n,m,k;
 int ans;
 int par[MAX_N];
 vector<Edge> edge;

 void read()
 {
     cin>>n>>k>>m;
     m--;
     int a,b,c1,c2;
     for(int i=;i<m;i++)
     {
         cin>>a>>b>>c1>>c2;
         edge.push_back(Edge(a,b,c1,c2));
     }
 }

 void init_union_find()
 {
     for(int i=;i<=n;i++)
     {
         par[i]=i;
     }
 }

 int find(int x)
 {
     return par[x]==x?x:par[x]=find(par[x]);
 }

 void unite(int x,int y)
 {
     int px=find(x);
     int py=find(y);
     if(px==py) return;
     par[px]=py;
 }

 bool same(int x,int y)
 {
     return find(x)==find(y);
 }

 bool check(int now)
 {
     init_union_find();
     int cnt=;
     int super=;
     for(int i=;i<m;i++)
     {
         Edge temp=edge[i];
         if(min(temp.fst,temp.sec)<=now)
         {
             if(!same(temp.sour,temp.dest))
             {
                 cnt++;
                 if(temp.fst<=now) super++;
                 unite(temp.sour,temp.dest);
             }
         }
     }
     return cnt==n- && super>=k;
 }

 void solve()
 {
     sort(edge.begin(),edge.end());
     int lef=;
     int rig=COST_MAX;
     while(rig-lef>)
     {
         int mid=(lef+rig)/;
         if(check(mid)) rig=mid;
         else lef=mid;
     }
     ans=rig;
 }

 void print()
 {
     cout<<ans<<endl;
 }

 int main()
 {
     read();
     solve();
     print();
 }