POJ 2289 Jamie's Contact Groups (二分+最大流)

题目大意：

有n个人，可以分成m个组，现在给出你每个人可以去的组的编号，求分成的m组中人数最多的组最少可以有多少人。

算法讨论：

首先喷一下这题的输入，太恶心了。

然后说算法：最多的最少，二分的字眼。二分什么，因为我们说的是组的人，所以要对组的流出量进行二分。其余的都连流量为1的边，然后对“小组”点的流出量二分连边，最后跑最大流判断

是否等于N即可。还是蛮简单的。

Codes：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct Edge{
    int from, to, cap, flow;
    Edge(int _from=0, int _to=0, int _cap=0, int _flow=0):
            from(_from), to(_to), cap(_cap), flow(_flow) {}
}E[500000 + 5];

struct Dinic{
    static const int N = 1500 + 5;
    static const int M = 1050000 + 5;
    static const int oo = 0x3f3f3f3f;
    
    int n, m, s, t;
    vector <Edge> edges;
    vector <int> G[N];
    int cur[N], dis[N];
    bool vi[N];
    
    void Clear(){
        for(int i = 0; i <= n; ++ i) G[i].clear();
        edges.clear();
    }
    void Add(int from, int to, int cap, int flow){
        edges.push_back((Edge){from, to, cap, 0});
        edges.push_back((Edge){to, from, 0, 0});
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool bfs(){
        memset(vi, false, sizeof vi);
        dis[s] = 0; vi[s] = true;
        queue <int> q;
        q.push(s);
        while(!q.empty()){
            int x = q.front(); q.pop();
            for(int i = 0; i < G[x].size(); ++ i){
                Edge &e = edges[G[x][i]];
                if(!vi[e.to] && e.cap > e.flow){
                    vi[e.to] = true;
                    dis[e.to] = dis[x] + 1;
                    q.push(e.to);
                }
            }
        }
        return vi[t];
    }
    int dfs(int x, int a){
        if(x == t || a == 0) return a;
        int flw = 0, f;
        for(int &i = cur[x]; i < G[x].size(); ++ i){
            Edge &e = edges[G[x][i]];
            if(dis[x] + 1 == dis[e.to] && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0){
                e.flow += f; edges[G[x][i]^1].flow -= f;
                a -= f; flw += f;
                if(a == 0) break;
            }
        }
        return flw;
    }
    int MaxFlow(int s, int t){
        this->s = s; this->t = t;
        int flw = 0;
        while(bfs()){
            memset(cur, 0, sizeof cur);
            flw += dfs(s, oo);
        }
        return flw;
    }
}Net;

int n, m;
char buf[5000];
int len, cnt = 0, x, np;
int bj[10000 + 5];
int l, r, mid;

bool check(int mv){
    Net.Clear();
    for(int i = 1; i <= n; ++ i)
        Net.Add(0, i, 1, 0);
    for(int i = 1; i <= cnt; ++ i)
        Net.Add(E[i].from, E[i].to, 1, 0);
    for(int i = n + 1; i <= n + m; ++ i)
        Net.Add(i, n + m + 1, mv, 0);
    return Net.MaxFlow(0, n + m + 1) == n;
}

void Solve(){
    int ans, l = 1;
    while(l <= r){
        mid = l + (r - l) / 2;
        if(check(mid)){
            ans = mid; r = mid - 1;
        }
        else l = mid + 1;
    }
    printf("%d
", ans);
    return;
}
int main(){
    
    while(scanf("%d%d", &n, &m) && n && m){
        cnt = 0;r = 0;
        memset(bj, 0, sizeof bj);
        Net.n = n + m + 1;
        for(int i = 1; i <= n; ++ i){
            getchar();gets(buf);
            len = strlen(buf);
            for(int j = 0; j < len;){
                if(buf[j] < '0' || buf[j] > '9'){
                    j ++; continue;
                }
                while(buf[j] <= '9' && buf[j] >= '0'){
                    x = x * 10 + buf[j] - '0';j ++;
                }
                ++ cnt;
                E[cnt] = (Edge){i, x + 1 + n, 0, 0};
                bj[E[cnt].to] ++;
                r = max(bj[E[cnt].to], r);
                x = 0;
            }    
        }
        Solve();
    }
    return 0;
}