uvalive 3231

3231 - Fair Share
Asia - Seoul - 2004/2005
You are given N processors and M jobs to be processed. Two processors are specified to each job. To process
the job, the job should be allocated to and executed on one of the two processors for one unit of time. If K jobs
are allocated to a processor, then it takes K units of time for the processor to complete the jobs. To complete
all the jobs as early as possible, you should allocate the M jobs to the N processors as fair as possible.
Precisely speaking, you should minimize the maximum number of jobs allocated to each processor over all
processors. The quantity, minimum number of jobs, is called fair share.
For example, you are given 5 processors and 6 jobs. Each job can be allocated to one of the two processors as
shown in the table below. Job 1 can be allocated to processors 1 or 2, and job 2 can be allocated to processors
2 or 3, etc. If you allocate job 1 to processor 1, job 2 to processor 2, job 3 to processor 3, job 4 to processor 4,
job 5 to processor 5, and job 6 to processor 1, then you have at most two jobs allocated to each processor.
Since there are more jobs than processors in this example, some processors necessarily have at least two jobs,
and thus the fair share is two.
Given N processors, M jobs, and the sets of two processors to which the jobs can be allocated, you are to write
a program that finds the fair share. Processors are numbered from 1 to N and jobs are numbered from 1 to M .
It is assumed that the sets of two processors to which the jobs can be allocated are distinct over all jobs.
That is, if a job J1
can be allocated to processors P1
or P2
, and a job J2
which is different from J1
can be
allocated to processors P3
or P4
, then {P1
, P2
} {P3
, P4
}.
Input
The input consists of T test cases. The number of test cases T is given in the first line of the input file. Each
test case begins with a line containing an integer N, 1 N 1, 000, that represents the number of processors
in the test case. It is followed by a line containing an integer M, 1 M 10, 000, that represents the number
of jobs. In the following M lines, K-th line contains two distinct integers representing processors to which job
K can be allocated, 1 K M. The integers given in a line are separated by a space. After that, the remaining
test cases are listed in the same manner as the above.
3231 - Fair Share 1/2Output
Print exactly one line for each test case. The line should contain the fair share for that test case.
The following shows sample input and output for three test cases.
Sample Input
3
5
6
1 2
2 3
3 4
4 5
5 1
1 3
3
2
3 2
1 2
6
6
1 2
3 4
4 6
6 5
5 3
6 3
Sample Output
2
1
2
Seoul 2004-2005

二分加最大流

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 #include <vector>
 #include <climits>

 using namespace std;

 #define read() freopen("sw.in", "r", stdin)

 const int MAX = 2e5 + ;
 const int INF = 1e9 + ;
 vector <int> G[MAX];
 struct Edge {int from, to, cap, flow;};
 vector <Edge> edges;
 bool vis[MAX];
 int d[MAX];
 int cur[MAX];
 int u[MAX], v[MAX];

 int N, M, s, t;

 void add_edge(int from, int to, int cap) {
     edges.push_back((Edge) {from, to, cap, });
     edges.push_back((Edge) {to, from, , });
     int m = edges.size();
     G[from].push_back(m - );
     G[to].push_back(m - );

 }

 bool BFS() {
     memset(vis, , sizeof(vis));
     d[s] = ;
     vis[s] = ;
     queue <int> q;
     q.push(s);

     while (!q.empty()) {
         int x = q.front(); q.pop();
         for (int i = ; i < G[x].size(); ++i) {
             Edge &e = edges[ G[x][i] ];
             if (!vis[e.to] && e.cap > e.flow) {
                 d[e.to] = d[x] + ;
                 vis[e.to] = ;
                 q.push(e.to);
             }
         }

     }

     return vis[t];
 }

 int DFS(int x, int a) {
     if (x == t || a == ) return a;
     int flow = , f;
     for (int &i = cur[x]; i < G[x].size(); ++i) {
         Edge &e = edges[ G[x][i] ];
         if (d[e.to] == d[x] +  && (f = DFS(e.to, min(a, e.cap - e.flow))) > ) {
             e.flow += f;
             edges[ G[x][i] ^  ].flow -= f;
             flow += f;
             a -= f;
             if (a == ) break;
         }

     }

     return flow;
 }

 int Maxflow() {
     int flow = ;
     while (BFS()) {
         memset(cur, , sizeof(cur));
         flow += DFS(s, INF);
     }

     return flow;
 }

 bool check(int mid) {
     edges.clear();
     for (int i = ; i <= t; ++i) G[i].clear();

     for (int i = ; i <= N; ++i) {
         add_edge(s, i, mid);
     }

     for (int i = ; i <= M; ++i) {
         add_edge(N + i, t, );
     }

     for (int i = ; i <= M; ++i) {
         add_edge(u[i], N + i, );
         add_edge(v[i], N + i, );
     }

     return Maxflow() >= M;
 }
 void solve() {
     int l = , r = M;
     while (l < r) {
         int mid = (l + r) >> ;
        // printf("l = %d r = %d mid = %d\n", l, r, mid);
         if (check(mid)) r = mid;
         else l = mid + ;
     }

     printf("%d\n", l);
 }
 int main()
 {
     read();
     int T;
     scanf("%d", &T);
     for (int ca = ; ca <= T; ++ca) {
         scanf("%d%d", &N, &M);
         s = , t = N + M + ;
         for (int i = ; i <= M; ++i) {
             scanf("%d%d", &u[i], &v[i]);
         }

         solve();
     }
     //cout << "Hello world!" << endl;
     return ;
 }