poj3436 ACM Computer Factory

题意：

　　n个工厂加工电脑，电脑有p个部件。每个工厂加工的电脑必须是满足它对原材料的需求。p个部件，0代表不能有，1必须有，2代表可有可无。然后经过加工后，这个工厂输出的电脑各个部件的情况，0代表没有，1代表有。每个工厂有一个生产效率。求单位时间内的最多能生产的完整电脑数量。

解决：

　　每个工厂拆成两个点，流量为该工厂效率。超级源连接对p个部件需求都为0的工厂，超级汇连接输出p个部件都为1的工厂 。求一次最大流。

#include <cstdio>
#include <cstring>
#include <queue>
#include <climits>

const int MAXN = 100 + 20;
const int INF = INT_MAX;

int g[MAXN];

int n, p;

struct Mach{
    int q, in[11], out[11];
}mach[MAXN<<2];

struct Edge{
    int v, f, pre;
}e[MAXN*MAXN], e_bak[MAXN*MAXN];
int e_n;

struct Flow{
    int u, v, f;
}flow[MAXN<<2];
int f_e;

int layer[MAXN];

int dfs(int u, int sink, int flow)
{
    if(u == sink)
        return flow;
    int now_flow = 0;
    for(int i = g[u]; i && flow; i = e[i].pre){
        int v = e[i].v;
        int f = e[i].f;
        if(f > 0 && layer[v] == layer[u] + 1){
            int d = dfs(v, sink, std::min(f, flow));
            e[i].f -= d;
            e[i^1].f += d;
            flow -= d;
            now_flow += d;
        }
    }
    return now_flow;
}

void bfs(int src, int sink)
{
    memset(layer, -1, sizeof layer);
    std::queue<int> que;
    que.push(src);
    layer[src] = 0;
    while(que.empty() == false){
        int u = que.front();
        que.pop();
        for(int i = g[u]; i; i = e[i].pre){
            int v = e[i].v;
            int f = e[i].f;
            if(f > 0 && layer[v] == -1){
                que.push(v);
                layer[v] = layer[u] + 1;
            }
        }
    }
}

int dinic(int src, int sink)
{
    int res = 0;
    while(true){
        bfs(src, sink);
        if(layer[sink] == -1){
            return res;
        }
        res += dfs(src, sink, INF);
    }
}



void addEdge(int u, int v, int f)
{
    ++ e_n;
    e[e_n].v = v;
    e[e_n].f = f;
    e[e_n].pre = g[u];
    g[u] = e_n;
    
    ++e_n;
    e[e_n].v = u;
    e[e_n].f = 0;
    e[e_n].pre = g[v];
    g[v] = e_n;
}

void init()
{
    e_n = 1;
    f_e = 0;
    memset(g, 0, sizeof g);
    memset(e, 0, sizeof e);
    memset(e_bak, 0, sizeof e_bak);
    memset(flow, 0, sizeof flow);
    memset(mach, 0, sizeof mach);
}

int main()
{
    while(~scanf("%d%d", &p, &n)){
        init();
        //scanf("%d%d", &p, &n);
        int src = 0;
        int sink = n*2+1;
        // input
        for(int i = 1; i <= n; ++ i){
            scanf("%d", &mach[i].q);
            for(int j = 1; j <= p; ++ j){
                scanf("%d", &mach[i].in[j]);
            }
            for(int j = 1; j <= p; ++ j){
                scanf("%d", &mach[i].out[j]);
            }    
            addEdge(i, i+n, mach[i].q);
        }
        // addEdge
        for(int i = 1; i <= n; ++ i){
            bool ok = true;
            for(int j = 1; j <= p; ++ j){
                if(mach[i].in[j] == 1){
                    ok = false;
                    break;
                }
            }
            if(ok == true){
                addEdge(src, i, INF);
            }
    
            ok = true;
            for(int j = 1; j <= p; ++ j){
                if(mach[i].out[j] != 1){
                    ok = false;
                    break;
                }
            }
            if(ok == true){
                addEdge(i+n, sink, INF);
            }
    
            for(int j = 1; j <= n; ++ j){
                if(i == j){
                    continue;
                }
                ok = true;
                for(int k = 1; k <= p; ++ k){
                    if(mach[i].in[k] == 1 && mach[j].out[k] == 0){
                        ok = false;
                        break;
                    }
                    if(mach[i].in[k] == 0 && mach[j].out[k] == 1){
                
                        ok = false;
                        break;
                    }
                }
                if(ok == true){
                    addEdge(j+n, i, INF);
                }
            }
        }
    
        for(int i = 2; i <= e_n; ++ i){
            e_bak[i] = e[i];
        }

        printf("%d ", dinic(src, sink));

        for(int u = n+1; u <= n*2; ++ u){
            for(int i = g[u]; i; i = e[i].pre){
                int v = e[i].v;
                if(v == 0 || v > n)
                    continue;
                int f = e[i].f;
                int f_bak = e_bak[i].f;
                if(f_bak > f){
                    f_e ++;
                    flow[f_e].u = u-n;
                    flow[f_e].v = v;
                    flow[f_e].f = f_bak - f;
                }
            }
        }
        printf("%d
", f_e);
        for(int i = 1; i <= f_e; ++ i){
            printf("%d %d %d
", flow[i].u, flow[i].v, flow[i].f);
        }
    }
}