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 = 110,INF = (int)1e9;
int p,n,tot;
int G[N][N],head[N],lev[N];
queue<int > que;
struct info{
    int in[20],out[20];
    int cap;
}info[N];//存机器的信息
struct node{
    int to,nxt,flow;
}e[N*N];

void init_main(){
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= n; ++j) G[i][j] = 0;

    for(int i = 0; i <= 2*n+1; ++i) head[i] = -1; tot = 0;
}

void init_bfs(){
    for(int i = 1; i <= 2*n+1; ++i) lev[i] = 0;
    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 = 1; i <= p; ++i){
        if(info[y].in[i] == 2) continue;
        if(info[x].out[i] != info[y].in[i]) return false;
    }
    return true;
}

//建边
void rebuild(){
    for(int i = 1; i <= n; ++i){
        if(check(0,i)){
            add(0,i,INF); add(i,0,0);
        }
        if(check(i,2*n+1)){
            add(i+n,2*n+1,INF); add(2*n+1,i+n,0);
        }
    }
    for(int i = 1; i <= n; ++i){
        for(int j = 1; j <= n; ++j){
            if(i == j){
                add(i,i+n,info[i].cap); add(i+n,i,0);
            }
            else if(check(i,j)){
                add(i+n,j,INF); add(j,i+n,0);
            }
        }
    }
}

int dfs(int now,int flow,int t){
    if(now == t) return flow;
    int to,sum = 0,tmp = 0;
    for(int o = head[now]; ~o; o = e[o].nxt){
        to = e[o].to;
        if((lev[to] == lev[now] +1) && e[o].flow && (tmp = dfs(to,min(flow - sum, e[o].flow),t))){
            //需要的路径流量  G数组来存机器之间的联系
            if(now > n && now < 2*n+1 && to != 2*n+1){
                G[now-n][to] += tmp;
            }
            e[o].flow -= tmp;
            e[o^1].flow += tmp;
            if((sum += tmp) == flow) return sum;
        }
    }
    return sum;
}

bool bfs(int s,int t){
    init_bfs();
    que.push(0);
    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] + 1;
                que.push(to);
            }
        }
    }
    if(lev[t]) return true;
    else return false;
}

int mf(int s,int t){
    int max_flow = 0;
    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 = 1; i <= n; ++i){
            scanf("%d",&info[i].cap);
            for(int j = 1; j <= p; ++j) scanf("%d",&info[i].in[j]);
            for(int j = 1; j <= p; ++j) scanf("%d",&info[i].out[j]);
        }
        info[0].cap = INF; info[2*n+1].cap = INF;
        for(int i = 1; i <= p; ++i){
            info[0].out[i] = 0;
            info[2*n+1].in[i] = 1;
        }
        //建图
        rebuild();
        //Dinic
        int _mf = mf(0,2*n+1),line = 0;
        //统计需要的联系数量
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(G[i][j]) ++line;
            }
        }
        printf("%d %d
",_mf,line);
        //输出联系
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(G[i][j]) printf("%d %d %d
",i,j,G[i][j]);
            }
        }
     }

    return 0;
}