poj2289 Jamie's Contact Groups

思路：

二分+最大流。
实现：

 #include <stdio.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
 #include <assert.h>
 #include <queue>
 #include <vector>
 #include <algorithm>
 #include <iostream>
 #include <sstream>

 #define N (1500 + 2)
 #define M (N * N + 4 * N)

 typedef long long LL;

 using namespace std;

 struct edge
 {
     int v, cap, next;
 };
 edge e[M];

 int head[N], level[N], cur[N];
 int num_of_edges;

 /*
  * When there are multiple test sets, you need to re-initialize before each
  */
 void dinic_init(void)
 {
     num_of_edges = ;
     memset(head, -, sizeof(head));
     return;
 }

 int add_edge(int u, int v, int c1, int c2)
 {
     int& i = num_of_edges;

     assert(c1 >=  && c2 >=  && c1 + c2 >= ); // check for possibility of overflow
     e[i].v = v;
     e[i].cap = c1;
     e[i].next = head[u];
     head[u] = i++;

     e[i].v = u;
     e[i].cap = c2;
     e[i].next = head[v];
     head[v] = i++;
     return i;
 }

 void print_graph(int n)
 {
     for (int u = ; u < n; u++)
     {
         printf("%d: ", u);
         for (int i = head[u]; i >= ; i = e[i].next)
         {
             printf("%d(%d)", e[i].v, e[i].cap);
         }
         printf("\n");
     }
     return;
 }

 /*
  * Find all augmentation paths in the current level graph
  * This is the recursive version
  */
 int dfs(int u, int t, int bn)
 {
     if (u == t) return bn;
     int left = bn;
     for (int &i = cur[u]; i >= ; i = e[i].next)
     {
         int v = e[i].v;
         int c = e[i].cap;
         if (c >  && level[u] +  == level[v])
         {
             int flow = dfs(v, t, min(left, c));
             if (flow > )
             {
                 e[i].cap -= flow;
                 e[i ^ ].cap += flow;
                 cur[u] = i;
                 left -= flow;
                 if (!left) break;
             }
         }
     }
     if (left > ) level[u] = ;
     return bn - left;
 }

 bool bfs(int s, int t)
 {
     memset(level, , sizeof(level));
     level[s] = ;
     queue<int> q;
     q.push(s);
     while (!q.empty())
     {
         int u = q.front();
         q.pop();
         if (u == t) return true;
         for (int i = head[u]; i >= ; i = e[i].next)
         {
             int v = e[i].v;
             if (!level[v] && e[i].cap > )
             {
                 level[v] = level[u] + ;
                 q.push(v);
             }
         }
     }
     return false;
 }

 LL dinic(int s, int t)
 {
     LL max_flow = ;

     while (bfs(s, t))
     {
         memcpy(cur, head, sizeof(head));
         max_flow += dfs(s, t, INT_MAX);
     }
     return max_flow;
 }

 vector<int> v[N];
 int n, m;
 bool check(int x)
 {
     dinic_init();
     for (int i = ; i <= n; i++)
     {
         for (int j = ; j < v[i].size(); j++)
         {
             add_edge(i, v[i][j] + n + , , );
         }
     }
     for (int i = ; i <= n; i++)
         add_edge(, i, , );
     for (int j = n + ; j <= n + m; j++)
     {
         add_edge(j, n + m + , x, );
     }
     return dinic(, n + m + ) == n;
 }

 int main()
 {
     while (cin >> n >> m, n || m)
     {
         getchar();
         string s, name;
         int group;
         for (int i = ; i <= n; i++) v[i].clear();
         for (int i = ; i <= n; i++)
         {
             getline(cin, s);
             stringstream ss(s);
             ss >> name;
             while (ss >> group)
             {
                 v[i].push_back(group);
             }
         }
         int l = , r = n, ans = n;
         while (l <= r)
         {
             int m = (l + r) >> ;
             if (check(m))
             {
                 r = m - ; ans = m;
             }
             else l = m + ;
         }
         cout << ans << endl;
     }
     return ;
 }