POJ 3436 ACM Computer Factory (网络流）

题目

题意：
生产线是全自动化的，所以需要机器来组成生产线，给定有多少中种机器，标准ACM用电脑有多少部份，每种机器将什么样的ACM电脑半成品处理成什么样的电脑半成品(对于输入的电脑半成品，每部分有0，1，2三种状态：代表着 0、这部分必须没有我才能处理，1、这部分必须有我才能处理，2、这部分有没有我都能处理。对于输出的电脑半成品有0，1两种状态：代表着0，处理完后的电脑半成品里没有这部分，1、处理完的电脑半成品有这部分)，每一个机器每小时可以处理Q个半成品（输入数据中的Qi）。
输入规格有三种情况：0,1,2
0：该部分不能存在
1：该部分必须保留
2：该部分可有可无
输出规格有2种情况：0,1
0：该部分不存在
1：该部分存在

求组装好的成产线的最大工作效率（每小时最多生成多少成品，成品的定义就是所有部分的状态都是“1”），和每两个机器之间的流量。

思路：
根据对机器的要求，来进行拆点，从而新建一个图。添加两个超级源s,超级汇t如果某个节点(i)的输入部分不含1，则添加一条s->i路径，容量为Qi;如果某个节点(j)输出全为1，则添加一条j->t路径，容量为Qj;如果节点i的输出与j的输入不存在冲突(输出与输入对应位置的和不能为1)，则添加一条i->j的路径，容量为min(Qi, Qj).

#include <iostream>
#include <cstring>
#include<cstdio>
#define LL long long
#include <queue>
const int MAXN =205;
const int MAXM=440020;
const int INF=0x3f3f3f3f;
using namespace std;
struct Edge
{
    int from;
    int to,cap,flow,next;
} edge[MAXM];
int head[MAXN],tot,gap[MAXN],d[MAXN],cur[MAXN],que[MAXN],p[MAXN];

void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}

void addedge(int u,int v,int c,int f)
{
    edge[tot]=(Edge)
    {
        u,v,c,f,head[u]
    };
    head[u] = tot++;
    edge[tot]=(Edge)
    {
        v,u,c,c,head[v]
    };
    head[v] = tot++;
}

int isap(int source,int sink,int N)
{
    memset(gap,0,sizeof(gap));
    memset(d,0,sizeof(d));
    memcpy(cur,head,sizeof(head));
    int top = 0,x = source,flow = 0;
    while(d[source] < N)
    {
        if(x == sink)
        {
            int Min = INF,inser=0;
            for(int i = 0; i < top; ++i)
            {
                if(Min > edge[p[i]].cap - edge[p[i]].flow)
                {
                    Min = edge[p[i]].cap - edge[p[i]].flow;
                    inser = i;
                }
            }
            for(int i = 0; i < top; ++i)
            {
                edge[p[i]].flow += Min;
                edge[p[i]^1].flow -= Min;
            }
            if(Min!=INF) flow += Min;
            top = inser;
            x = edge[p[top]^1].to;
            continue;
        }
        int ok = 0;
        for(int i = cur[x]; i != -1; i = edge[i].next)
        {
            int v = edge[i].to;
            if(edge[i].cap > edge[i].flow && d[v]+1 == d[x])
            {
                ok = 1;
                cur[x] = i;
                p[top++] = i;
                x = edge[i].to;
                break;
            }
        }
        if(!ok)
        {
            int Min = N;
            for(int i = head[x]; i != -1; i = edge[i].next)
            {
                if(edge[i].cap > edge[i].flow && d[edge[i].to] < Min)
                {
                    Min = d[edge[i].to];
                    cur[x] = i;
                }
            }
            if(--gap[d[x]] == 0) break;
            gap[d[x] = Min+1]++;
            if(x != source) x = edge[p[--top]^1].to;
        }
    }
    return flow;
}

int state[MAXN][2][10];
int pp,n;

int equall(int x,int y)
{
    for(int i=0;i<pp;i++)
        if(state[y][0][i]+state[x][1][i]==1)
            return 0;

    return 1;
}
int main()
{
//    freopen("in.txt","r",stdin);
    int w,flag1,flag2;
    while(~scanf("%d%d",&pp,&n))
    {
        init();
        memset(state,0,sizeof(state));

        for(int i=1;i<=n;i++)
        {
            flag1=flag2=1;
            scanf("%d",&w);
            for(int j=0;j<pp;j++){      //全是0或2 则连接源点
                scanf("%d",&state[i][0][j]);
                if(state[i][0][j]==1)
                    flag1=0;
            }

            for(int j=0;j<pp;j++){       //全是1 则连接汇点
                scanf("%d",&state[i][1][j]);
                if(state[i][1][j]==0||state[i][1][j]==2)
                    flag2=0;
            }

            addedge(i,i+n,w,0);          //拆点连自己

            if(flag1==1)
                addedge(0,i,INF,0);
            if(flag2==1)
                addedge(i+n,2*n+1,INF,0);

            for(int j=1;j<i;j++){
                if(equall(i,j))
                    addedge(n+i,j,INF,0);
                if(equall(j,i))           //注意不能是else if 两个机器可以是双向连接的
                    addedge(n+j,i,INF,0);
            }
        }

        printf("%d",isap(0,2*n+1,2*n+2));

        int ans[400][3];
        int ss=0;
        for(int i=n+1;i<=(n<<1);i++)      //邻接表找最大流中的边
            for(int j=head[i];j!=-1;j=edge[j].next)
            {
                if(edge[j].to==2*n+1||edge[j].to==i-n)
                    continue;
                if(edge[j].flow>0){
                    ans[ss][0]=edge[j].from-n;
                    ans[ss][1]=edge[j].to;
                    ans[ss++][2]=edge[j].flow;
                }
            }
        printf(" %d\n",ss);
        for(int i=0;i<ss;i++)
            printf("%d %d %d\n",ans[i][0],ans[i][1],ans[i][2]);
    }
    return 0;
}