hdu 3081

二分答案，网络流是否满流判断合法性。

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 #define maxn 210
 #define oo 0x3f3f3f3f
 using namespace std;

 struct Edge {
     int u, v, f;
     Edge( int u, int v, int f ):u(u),v(v),f(f){}
 };
 struct Dinic {
     int n, src, dst;
     vector<Edge> edge;
     vector<int> g[maxn];
     int dep[maxn], cur[maxn];

     void init( int n, int src, int dst  ) {
         this->n = n;
         this->src = src;
         this->dst = dst;
         for( int u=; u<=n; u++ )
             g[u].clear();
         edge.clear();
     }
     void add_edge( int u, int v, int f ) {
         g[u].push_back( edge.size() );
         edge.push_back( Edge(u,v,f) );
         g[v].push_back( edge.size() );
         edge.push_back( Edge(v,u,) );
     }
     bool bfs() {
         queue<int> qu;
         memset( dep, , sizeof(dep) );
         qu.push( src );
         dep[src] = ;
         while( !qu.empty() ) {
             int u=qu.front();
             qu.pop();
             for( int &t=cur[u]; t<g[u].size(); t++ ) {
                 Edge &e = edge[g[u][t]];
                 if( e.f && !dep[e.v] ) {
                     dep[e.v] = dep[e.u]+;
                     qu.push( e.v );
                 }
             }
         }
         return dep[dst];
     }
     int dfs( int u, int a ) {
         if( u==dst || a== ) return a;
         int remain=a, past=, na;
         for( int &t=cur[u]; t<g[u].size(); t++ ) {
             Edge &e = edge[g[u][t]];
             Edge &ve = edge[g[u][t]^];
             if( dep[e.v]==dep[e.u]+ && (na=dfs(e.v,min(remain,e.f))) ) {
                 remain -= na;
                 past += na;
                 e.f -= na;
                 ve.f += na;
                 if( remain== ) break;
             }
         }
         return past;
     }
     int maxflow() {
         int flow = ;
         while( bfs() ) {
             memset( cur, , sizeof(cur) );
             flow += dfs(src,oo);
         }
         return flow;
     }
 };

 int fa[maxn];

 void init( int n ) {
     for( int i=; i<=n; i++ )
         fa[i] = i;
 }
 int find( int a ) {
     return a==fa[a] ? a : fa[a]=find(fa[a]);
 }
 void unon( int a, int b ) {
     a = find(a);
     b = find(b);
     fa[a] = b;
 }

 int n, m, f;
 bool cnnt[][];
 int cnt[];
 vector<int> stk;
 Dinic D;

 bool ok( int mid ) {
     D.init( n+n+, n+n+, n+n+ );
     for( int u=; u<=n; u++ ) {
         if( fa[u]!=u ) continue;
         D.add_edge( D.src, u, mid*cnt[u] );
         for( int v=; v<=n; v++ ) {
             if( !cnnt[u][v] ) continue;
             D.add_edge( u, v+n, cnt[u] );
         }
     }
     for( int v=; v<=n; v++ )
         D.add_edge( v+n, D.dst, mid );
     return D.maxflow()==mid*n;
 }
 int main() {
     int T;
     scanf( "%d", &T );
     while( T-- ) {
         scanf( "%d%d%d", &n, &m, &f );
         memset( cnnt, , sizeof(cnnt) );
         for( int i=,u,v; i<=m; i++ ) {
             scanf( "%d%d", &u, &v );
             cnnt[u][v] = ;
         }
         init(n);
         for( int i=,u,v; i<=f; i++ ) {
             scanf( "%d%d", &u, &v );
             unon(u,v);
         }
         memset( cnt, , sizeof(cnt) );
         for( int i=; i<=n; i++ ) {
             int r = find(i);
             cnt[r]++;
             for( int j=; j<=n; j++ )
                 cnnt[r][j] |= cnnt[i][j];
         }
         stk.clear();
         for( int i=; i<=n; i++ )
             if( fa[i]==i ) stk.push_back(i);
         int lf=, rg=n;
         while( lf<rg ) {
             int mid = (lf+rg+)>>;
             if( ok(mid) ) lf=mid;
             else rg=mid-;
         }
         printf( "%d\n", lf );
     }
 }