ACM Computer Factory（网络毒流）

题目链接：http://poj.org/problem?id=3436

题目大意

给你n个机器，每个机器给你三部分数，第一部分，一个数，表示这个机器最大可以完成多少次这个操作，第二部分m个数，表示来这个机器前的状态要求，第三部分m个数，表示经过这个机器之后，形成的状态。
全0表示最初状态，全1表示最终要转化成的状态。（初状态中，1表示一定要有，0表示一定要没有，2表示有没有都可以。）
让我们求最大可以转换成最终状态的个数，并输出路径。

思路

一道毒瘤题，一点不假。。。先把每个机器拆开来，把初状态和末状态连一条边，边权为这个机器的最大完成数。然后再把末状态和别的符合的初状态连边，边权值inf，还要有一个超级源点连全0，边权inf，超级终点连全1，边权inf，然后跑Dinic最大流，就能得到最大流答案。
但是路径的话，我们要找那些不同机器之间的流量，也就是找那些把自己末状态连接到别的机器的初状态的两个机器之间，本来边权为inf，如果小了，就说明这条边流过流量，那么记录两个机器编号，流量就是inf-当前的权值。

AC (poj G++)

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<math.h>
//#include<bits/stdc++.h>
#include<map>
using namespace std;
#define LL long long
#define inf 0x3f3f3f3f
double eps=1e-10;
const LL N=1e2+10;
int n,m;
struct zxc
{
    int to,net,w;
} e[N*N];
int tot=0;
int s,t;
int maxflow;
int head[N];
int q[N][15];
int h[N][15];
int v[N];
int vis[N];
int dep[N];
int ans[N][5];
void init()
{
    tot=1;
    maxflow=0;
    memset(head,-1,sizeof(head));
    memset(dep,inf,sizeof(dep));
}
void add(int u,int vv,int w)
{
    e[tot]= {vv,head[u],w};
    head[u]=tot++;
}
int bfs()//分层
{
    queue<int>q;
    memset(vis,0,sizeof(vis));
    memset(dep,inf,sizeof(dep));
    q.push(s);
    vis[s]=1;
    dep[s]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u]; i!=-1; i=e[i].net)
        {
            int y=e[i].to;
            if(dep[y]>dep[u]+1&&e[i].w>0)
            {
                dep[y]=dep[u]+1;
                if(!vis[y])
                {
                    vis[y]=1;
                    q.push(y);
                }
            }
        }
    }
    if(dep[t]==0x3f3f3f3f)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
int dfs(int x,int flow)//多次增广
{
    int row=0;
    if(x==t)return flow;
    for(int i=head[x];i!=-1;i=e[i].net)
    {
        int y=e[i].to;
        if(dep[y]==dep[x]+1&&e[i].w>0)
        {
            if(row=dfs(y,min(flow,e[i].w)))
            {
                e[i].w-=row;
                return row;
            }
        }
    }
    return 0;
}
void Dinic()
{
    while(bfs())
    {
        int flow;
        while(flow=dfs(s,inf))
        {
            maxflow+=flow;
        }
    }
}
int main()
{
    scanf("%d%d",&m,&n);
    init();
    s=0;
    t=2*n+1;
    int sum1=0,sum2=0;
    for(int i=1; i<=n; i++)
    {
        sum1=0,sum2=0;
        scanf("%d",&v[i]);
        for(int j=1; j<=m; j++)
        {
            scanf("%d",&q[i][j]);
            if(q[i][j]==1)
            {
                sum1=1;
            }
        }
        for(int j=1; j<=m; j++)
        {
            scanf("%d",&h[i][j]);
            if(h[i][j]==0)
            {
                sum2=1;
            }
        }
        add(i*2-1,i*2,v[i]);
        if(!sum1)
        {
            add(s,i*2-1,inf);
        }
        if(!sum2)
        {
            add(i*2,t,inf);
        }
    }
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            if(i!=j)
            {
                int flog=0;
                for(int k=1; k<=m; k++)
                {
                    if(h[i][k]+q[j][k]==1)
                    {
                        flog=1;
                    }
                }
                if(!flog)
                {
                    add(i*2,j*2-1,inf);

                }
            }
        }
    }
    Dinic();
    printf("%d ",maxflow);
    int ax=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i*2];j!=-1;j=e[j].net)
        {

            int y=e[j].to;
            if(y!=t&&e[j].w<inf)
            {
                ans[++ax][1]=i;
                ans[ax][2]=(y+1)/2;
                ans[ax][3]=inf-e[j].w;
            }
        }
    }
    printf("%d\n",ax);
    for(int i=1;i<=ax;i++)
    {
        printf("%d %d %d\n",ans[i][1],ans[i][2],ans[i][3]);
    }
    return 0;
}