poj 3436 ACM Computer Factory (最大流)

题意很复杂。。

大意：n个机器生产电脑，电脑有p个部件。每台机器能够将含某些部件的电脑转换为含另一些部件的电脑。

已知各个机器的最大生产速率以及转换条件，0表示该机器不需要该部件，1表示需要，2表示可有可无。

问怎样安排流水线生产，使得生产速率最大。

一、建图：

1、将每个机器视为一个点。

2、添加一个源点，转换条件及产出均为0；添加一个汇点，转换条件及产出均为1.

3、对于任意两个点，看其中一个产出能否和另一个的转换条件对应，若能，二者连一条边。容量为二者生产速率的较小值。

另外，除了上述建图方式外，还可以采用拆点的方式来建图：

1) 添加一个原点S,S提供最初的原料 00000...
2) 添加一个汇点T, T接受最终的产品 11111....
3) 将每个机器拆成两个点: 编号为i的接收节点，和编号为i+n的产出节点（n是机器数目），前者用于接收原料，后者用于提供加工后的半成品或成品。这两个点之间要连一条边，容量为单位时间产量Qi
4) S 连边到所有接收 "0000..." 或 "若干个0及若干个2" 的机器，容量为无穷大
5) 产出节点连边到能接受其产品的接收节点，容量无穷大
6) 能产出成品的节点，连边到T，容量无穷大。

二、求解

采用了链式前向星存图+递归的Dinic来求解。

由于要输出流量，因此建图的时候需要将原图备份，即加一个变量存原容量。求出最大流之后，原容量减去残余网络中的剩余容量即为流量。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef __int64 LI;
typedef unsigned __int64 uLI;
typedef unsigned int uI;
typedef double db;
#define maxn 1005
#define inf 0x3f3f3f3f
struct Edge
{
    int from,to,cap,v,next;
}edge[maxn];

int cnt,head[maxn],d[maxn],s,t;

inline void add(int u,int v,int w)
{
    edge[cnt].from=u;
    edge[cnt].to=v;
    edge[cnt].cap=w;
    edge[cnt].next=head[u];
    edge[cnt].v=w;
    head[u]=cnt++;
}

inline bool bfs()   //BFS构造层次图
{
    int u,i;
    queue<int> q;
    q.push(s);
    memset(d,0,sizeof(d));
    d[s]=1;
    while(!q.empty())
    {
        u=q.front();q.pop();
        if(u==t) return true;   //汇点的层次被算出即可停止，因为根据DFS的规则，和汇点同层或更下一层的结点是不可能走到汇点的。
        for(i=head[u];~i;i=edge[i].next){
            int v=edge[i].to;
            if(!d[v]&&edge[i].cap>0)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int a)  //当前结点、目前为止所有弧的最小残量
{
    int flow=0,f,i;
    if(u==t||a==0) return a;
    for(i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(edge[i].cap>0&&d[v]==d[u]+1)   //满足容量不为0且另一端是下一层次
        {
            f=dfs(v,min(a,edge[i].cap));
            edge[i].cap-=f; //削减路径上各边的容量
            edge[i^1].cap+=f;//添加反向边
            flow+=f;    //增加总流量
            a-=f;   //该结点之前的弧的最小残量削减f后的值
            if(!a) break;   //若为0，则无需再从该结点寻找增广路，因为位于该结点之前的某条弧削减f后会为0，导致无法从源点经过该结点再增广到汇点
        }
    }
    if(flow==0) d[u]=0; //从该点出发找不到增广路，则将该点从层次图中去掉
    return flow;
}

int dinic()
{
    int ans=0;
    while(bfs()) ans+=dfs(s,inf);
    return ans;
}


int M[55][55];
int main()
{
    int i,j,k,p,n;
    while(~scanf("%d%d",&p,&n))
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        for(i=1;i<=n;++i)
            for(j=0;j<=2*p;++j) scanf("%d",&M[i][j]);
        ++n;
        for(i=0;i<=2*p;++i) {M[0][i]=0;M[n][i]=1;}
        s=0,t=n;
        for(i=0;i<=n;++i)
        for(j=0;j<=n;++j){
            if(i==j) continue;
            bool flag=1;
            for(k=1;k<=p;++k)
                if(M[i][k+p]!=M[j][k]&&M[j][k]!=2) {flag=0;break;}
            if(flag) {
                int w;
                if(i==0) w=M[j][0];
                else if(j==n) w=M[i][0];
                else w=min(M[i][0],M[j][0]);
                add(i,j,w);
                add(j,i,0);
            }
        }
        printf("%d ",dinic());
        int tot=0;
        for(i=0;i<cnt;i+=2)
            if(edge[i].v-edge[i].cap>0&&edge[i].from!=0&&edge[i].to!=n) ++tot;
        printf("%d\n",tot);
        for(i=0;i<cnt;i+=2)
            if(edge[i].v-edge[i].cap>0&&edge[i].from!=0&&edge[i].to!=n) printf("%d %d %d\n",edge[i].from,edge[i].to,edge[i].v-edge[i].cap);
    }
    return 0;
}