A - ACM Computer Factory - poj 3436（最大流）

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;

const int MAXN = 107;
const int oo = 1e9+7;

int G[MAXN][MAXN], layer[MAXN], G1[MAXN][MAXN];
int P, N;///需要P个零件，N条生产线
///表示生产线，需要的零件in，输出的零件out，最大生产值Flow
struct node{int in[MAXN], out[MAXN], Flow;}a[MAXN];

void InIt()
{
    memset(G, false, sizeof(G));
    memset(G1, false, sizeof(G1));

    for(int i=1; i<=P; i++)
    {
        a[1].out[i] = 0;
        a[1].in[i] = 0;
        a[N+2].in[i] = 1;
        a[N+2].out[i] = 1;
    }
    a[1].Flow = oo;
    a[N+2].Flow = oo;
}
bool canLink(node n1, node n2)
{///n1输出的零件是否是n2需要的
    for(int i=1; i<=P; i++)
    {
        if(n1.out[i] != n2.in[i] && n2.in[i] != 2)
            return false;
    }

    return true;
}
bool bfs(int start, int End)
{
    int used[MAXN] = {0};
    queue<int> Q;Q.push(start);
    memset(layer, -1, sizeof(layer));
    used[start] = true, layer[start] = 0;

    while(Q.size())
    {
        int u = Q.front();Q.pop();

        if(u == End)return true;

        for(int i=1; i<=End; i++)
        {
            if(G[u][i] && !used[i])
            {
                used[i] = true;
                layer[i] = layer[u] + 1;
                Q.push(i);
            }
        }
    }

    return false;
}
int dfs(int u, int MaxFlow, int End)
{
    if(u == End)return MaxFlow;

    int uFlow = 0;

    for(int i=0; i<=End; i++)
    {
        if(layer[u]+1==layer[i] && G[u][i])
        {
            int flow = min(MaxFlow-uFlow, G[u][i]);
            flow = dfs(i, flow, End);

            G[u][i] -= flow;
            G[i][u] += flow;
            uFlow += flow;

            if(uFlow == MaxFlow)
                break;
        }
    }

    return uFlow;
}
int dinic(int start, int End)
{
    int MaxFlow = 0;

    while(bfs(start, End) == true)
        MaxFlow += dfs(start, oo, End);

    return MaxFlow;
}

int main()
{
    while(scanf("%d%d", &P, &N) != EOF)
    {
        int i, j;

        InIt();

        for(i=2; i<=N+1; i++)
        {
            scanf("%d", &a[i].Flow);
            for(j=1; j<=P; j++)
                scanf("%d", &a[i].in[j]);
            for(j=1; j<=P; j++)
                scanf("%d", &a[i].out[j]);
        }

        N+=2;

        for(i=1; i<=N; i++)
        for(j=1; j<=N; j++)
        {
            if(i == j)
            {
                G1[i][j+N] = G[i][j+N] = a[i].Flow;
            }
            else if(i!=j && canLink(a[i], a[j]) == true)
            {
                G1[i+N][j] = G[i+N][j] = a[i].Flow;
            }
        }

        int MaxFlow = dinic(1, N*2);
        int k=0, x[MAXN], y[MAXN], flow[MAXN];

        for(i=2; i<N; i++)
        for(j=2; j<N; j++)
        {
            if(G[i+N][j] < G1[i+N][j])
            {
                x[k] = i;
                y[k] = j;
                flow[k++] = G1[i+N][j] - G[i+N][j];
            }
        }

        printf("%d %d\n", MaxFlow, k);
        for(i=0; i<k; i++)
            printf("%d %d %d\n", x[i]-1, y[i]-1, flow[i]);
    }

    return 0;
}
/**
输入

3 5
10  0 0 0  0 1 0
10  0 0 0  0 1 0
10  0 1 0  0 1 1
10  0 1 1  1 1 1
10  0 1 1  1 1 1

输出

10 2
1 3 10
3 4 10

**/