POJ3436 ACM Computer Factory

题意：有p个部件，n个厂，每个厂可能需要一些部件也能产生一些部件，每个厂也有一个生产速度，输入的时候先是生产速度，然后p个数是生产需要的部件（0代表不要这个部件，1代表要，2代表可要可不要），最后是产生的部件（0代表不生产，1代表生产）。求最大的生产速度（要生产整个电脑）和流水线的个数（有流量边的个数）还有是怎么生产的。

首先要添加一个超级源点和超级汇点，把每个厂拆点，点之间的流量就是这个厂的生产速度，如果不需要生产任何部件就从源点连一条容量为INF的边，同样如果所有部件都能生产（也就是能直接生产电脑了），直接从拆点的另一个边向汇点连边，最后对每两个厂之间判断能不能匹配，也就是两个厂的任意两个部件之和不能为1也就是匹配了，如果有一个部件为1，代表要么不能生产，要么不要用。。然后在这种图下跑一遍最大流就是，最后找边，我是直接从拆点的另一个边（i,i+n），从i+n出发枚举找有流量的边（有几个判断条件），不能是反向边，不能流到终点，注意了这几个就可以A了。。

/*************************************************************************
	> File Name: poj3436.cpp
	> Author: tjw
	> Mail:
	> Created Time: 2014年10月31日 星期五 19时10分49秒
 ************************************************************************/

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<stack>
#include<map>
#define ll long long
#define ls k<<1
#define rs k<<1|1
using namespace std;
const int MAXN=200;
const int MAXE=10000;
const int INF=1<<30;
struct EDGE
{
    int v,next;
    int cap;
}edge[MAXE];
int head[MAXN],size;
void init()
{
    memset(head,-1,sizeof(head));
    size=0;
}
void add_edge(int u,int v,int cap)
{
    edge[size].v=v;
    edge[size].cap=cap;
    edge[size].next=head[u];
    head[u]=size++;
    edge[size].v=u;
    edge[size].cap=0;
    edge[size].next=head[v];
    head[v]=size++;
}
int gap[MAXN],dist[MAXN],pre[MAXN],pe[MAXN];
int ISAP(int s,int t)
{
    int cur_flow,u,i,neck,temp;
    int max_flow;
    memset(gap,0,sizeof(gap));
    memset(pre,-1,sizeof(pre));
    memset(dist,0,sizeof(dist));
    for(i=0;i<=t+1;i++)
        pe[i]=head[i];
    u=s;
    max_flow=0;
    while(dist[s]<t+1)
    {
        if(u==t)
        {
            cur_flow=INF;
            for(i=s;i!=t;i=edge[pe[i]].v)
            {
                if(cur_flow>edge[pe[i]].cap)
                {
                    cur_flow=edge[pe[i]].cap;
                    neck=i;
                }
            }
            for(i=s;i!=t;i=edge[pe[i]].v)
            {
                temp=pe[i];
                edge[temp].cap-=cur_flow;
                edge[temp^1].cap+=cur_flow;
            }
            max_flow+=cur_flow;
            u=neck;
        }
        for(i=pe[u];i!=-1;i=edge[i].next)
        {
            if(edge[i].cap&&dist[u]==dist[edge[i].v]+1)
                break;
        }
        if(i!=-1)
        {
            pe[u]=i;
            pre[edge[i].v]=u;
            u=edge[i].v;
        }
        else
        {
            if(0==--gap[dist[u]])
                break;
            pe[u]=head[u];
            temp=t+1;
            for(i=head[u];i!=-1;i=edge[i].next)
            {
                if(edge[i].cap)
                temp=min(temp,dist[edge[i].v]);
            }
            dist[u]=temp+1;
            ++gap[dist[u]];
            if(u!=s)
                u=pre[u];
        }
    }
    return max_flow;
}
int n,m;
int st[55][15],ed[55][15];
bool judge(int a,int b)
{
    int i;
    for(i=0;i<m;i++)
    {
        if(ed[a][i]+st[b][i]==1)
            return 0;
    }
    return 1;
}
int out[MAXN][3];
int main()
{
    int i,j;
    while(scanf("%d%d",&m,&n)==2)
    {
        init();
        int s=0,t=2*n+1;
        int x;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&x);
            add_edge(i,i+n,x);
            for(j=0;j<m;j++)
                scanf("%d",&st[i][j]);
            for(j=0;j<m;j++)
                scanf("%d",&ed[i][j]);
        }
        for(i=1;i<=n;i++)
        {
            int flag=1;
            for(j=0;j<m;j++)
            {
                if(st[i][j]==1)
                    flag=0;
            }
            if(flag)
                add_edge(s,i,INF);
            flag=1;
            for(j=0;j<m;j++)
            {
                if(ed[i][j]!=1)
                    flag=0;
            }
            if(flag)
                add_edge(i+n,t,INF);
            for(j=1;j<=n;j++)
            {
                if(i!=j&&judge(i,j))
                    add_edge(i+n,j,INF);
            }
        }
        int ans=ISAP(s,t);
        int u;
        int cnt=0;
        for(u=n+1;u<=2*n;u++)
        {
            for(i=head[u];i!=-1;i=edge[i].next)
            {
                int v=edge[i].v;
                if(!(i&1)&&edge[i^1].cap&&v!=t)
                {
                    out[cnt][0]=u-n;
                    out[cnt][1]=v;
                    out[cnt++][2]=edge[i^1].cap;
                }
            }
        }
        printf("%d %d\n",ans,cnt);
        for(i=0;i<cnt;i++)
        {
            printf("%d %d %d\n",out[i][0],out[i][1],out[i][2]);
        }
    }
    return 0;
}