kuangbin专题专题十一 网络流 POJ 3436 ACM Computer Factory

题目链接：https://vjudge.net/problem/POJ-3436

Sample input 1
3 4
15  0 0 0  0 1 0
10  0 0 0  0 1 1
30  0 1 2  1 1 1
3   0 2 1  1 1 1

题目：P  —— 一台电脑由p个零件组成

　　　N —— 工厂有n台加工组装电脑的机器

　 Q —— i-th机器每单位时间能工作的数量
　 
当每个未成品需要放入某个机器进一步加工的时候，它需要满足这台机器能正常工作的前提，
即它必须满足某些零件已经组装好了。
样例1： 前p个数字表示，进入i-th台机器，必须满足这些条件（0表示这个零件不能被安装  1表示这个零件必须被安装 2表示这个零件有无被安装无影响）
       后p个数字表示，某个未成品被i-th台机器加工完成后，满足了这些条件（0表示这个零件没被安装 1表示这个零件被安装了）
问：怎么安排机器工作方案，能使得工作效率最大化，安排情况有很多，输出一种即可。
 
思路：比较清楚，一个超级源点，一个超级汇点，一台机器需要拆成入点和出点，一台机器的入点和出点流量为该机器单位时间的工作量，其他点与点之间的流量就是INF了。
重点就是哪些边能建立起来比较麻烦，图建好了，跑一个Dinic就OK了。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <queue>
 #include <vector>
 using namespace std;
 
 const int N = ,INF = (int)1e9;
 int p,n,tot;
 int G[N][N],head[N],lev[N];
 queue<int > que;
 struct info{
     int in[],out[];
     int cap;
 }info[N];//存机器的信息
 struct node{
     int to,nxt,flow;
 }e[N*N];
 
 void init_main(){
     for(int i = ; i <= n; ++i)
         for(int j = ; j <= n; ++j) G[i][j] = ;
 
     for(int i = ; i <= *n+; ++i) head[i] = -; tot = ;
 }
 
 void init_bfs(){
     for(int i = ; i <= *n+; ++i) lev[i] = ;
     while(!que.empty()) que.pop();
 }
 
 inline void add(int u,int v,int flow){
     e[tot].to = v;
     e[tot].flow = flow;
     e[tot].nxt = head[u];
     head[u] = tot++;
 }
 
 //是否可连边
 inline bool check(int x,int y){
     for(int i = ; i <= p; ++i){
         if(info[y].in[i] == ) continue;
         if(info[x].out[i] != info[y].in[i]) return false;
     }
     return true;
 }
 
 //建边
 void rebuild(){
     for(int i = ; i <= n; ++i){
         if(check(,i)){
             add(,i,INF); add(i,,);
         }
         if(check(i,*n+)){
             add(i+n,*n+,INF); add(*n+,i+n,);
         }
     }
     for(int i = ; i <= n; ++i){
         for(int j = ; j <= n; ++j){
             if(i == j){
                 add(i,i+n,info[i].cap); add(i+n,i,);
             }
             else if(check(i,j)){
                 add(i+n,j,INF); add(j,i+n,);
             }
         }
     }
 }
 
 int dfs(int now,int flow,int t){
     if(now == t) return flow;
     int to,sum = ,tmp = ;
     for(int o = head[now]; ~o; o = e[o].nxt){
         to = e[o].to;
         if((lev[to] == lev[now] +) && e[o].flow && (tmp = dfs(to,min(flow - sum, e[o].flow),t))){
             //需要的路径流量  G数组来存机器之间的联系
             if(now > n && now < *n+ && to != *n+){
                 G[now-n][to] += tmp;
             }
             e[o].flow -= tmp;
             e[o^].flow += tmp;
             if((sum += tmp) == flow) return sum;
         }
     }
     return sum;
 }
 
 bool bfs(int s,int t){
     init_bfs();
     que.push();
     while(!que.empty()){
         int now = que.front(); que.pop();
         for(int o = head[now]; ~o; o = e[o].nxt){
             int to = e[o].to;
             if(!lev[to] && e[o].flow){
                 lev[to] = lev[now] + ;
                 que.push(to);
             }
         }
     }
     if(lev[t]) return true;
     else return false;
 }
 
 int mf(int s,int t){
     int max_flow = ;
     while(bfs(s,t)){
         max_flow += dfs(s,INF,t);
         //cout << "max_flow  " << max_flow << endl;
     }
     return max_flow;
 }
 
 int main(){
 
     while(~scanf("%d%d",&p,&n)){
         init_main();
         //读入信息  0超级源点   2*n+1超级汇点
         for(int i = ; i <= n; ++i){
             scanf("%d",&info[i].cap);
             for(int j = ; j <= p; ++j) scanf("%d",&info[i].in[j]);
             for(int j = ; j <= p; ++j) scanf("%d",&info[i].out[j]);
         }
         info[].cap = INF; info[*n+].cap = INF;
         for(int i = ; i <= p; ++i){
             info[].out[i] = ;
             info[*n+].in[i] = ;
         }
         //建图
         rebuild();
         //Dinic
         int _mf = mf(,*n+),line = ;
         //统计需要的联系数量
         for(int i = ; i <= n; ++i){
             for(int j = ; j <= n; ++j){
                 if(G[i][j]) ++line;
             }
         }
         printf("%d %d\n",_mf,line);
         //输出联系
         for(int i = ; i <= n; ++i){
             for(int j = ; j <= n; ++j){
                 if(G[i][j]) printf("%d %d %d\n",i,j,G[i][j]);
             }
         }
      }
 
     return ;
 }