POJ 3436 ACM Computer Factory（最大流+路径输出）

http://poj.org/problem?id=3436

题意：

每台计算机包含P个部件，当所有这些部件都准备齐全后，计算机就组装完成了。计算机的生产过程通过N台不同的机器来完成，每台机器用它的性能（每小时组装多少台电脑）、输入/输出规格来描述。

输入规格描述了机器在组装计算机时哪些部件必须准备好了。输入规格是由P个整数组成，每个整数代表一个部件，这些整数取值为0、1或2，其中0表示该部件不应该已经准备好了，1表示该部件必须已经准备好了，2表示该部件是否已经准备好了无关紧要。

输出规格描述了该机器组装的结果。输出规格也是由P个整数组成，每个整数取值 为0或1，其中0代表该部件没有生产好，1代表该部件生产好了。

输出每单位时间内的最大产量和连接数量和路径。

思路：
因为每台机器都有一个产量，所以这里拆点，容量为机器的产量。

对每台机器进行检验，如果它的要求中不包含1，那么它就和源点相连，说明这台机器是可以最先开始组装电脑的，如果它的输出中全是1，说明这台机器已经把电脑组装好了，和汇点相连。

然后机器之间两两判断，是否可以相连。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<sstream>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
typedef pair<int,int> pll;
const int INF = 0x3f3f3f3f;
const int maxn = 200 + 5;

struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int w,int f):from(u),to(v),cap(w),flow(f){}
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int cur[maxn];
    int d[maxn];

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;++i) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from,int to,int cap)
    {
        edges.push_back( Edge(from,to,cap,0) );
        edges.push_back( Edge(to,from,0,0) );
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        queue<int> Q;
        memset(vis,0,sizeof(vis));
        vis[s]=true;
        d[s]=0;
        Q.push(s);
        while(!Q.empty())
        {
            int x=Q.front(); Q.pop();
            for(int i=0;i<G[x].size();++i)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to] && e.cap>e.flow)
                {
                    vis[e.to]=true;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t || a==0) return a;
        int flow=0, f;
        for(int &i=cur[x];i<G[x].size();++i)
        {
            Edge &e=edges[G[x][i]];
            if(d[e.to]==d[x]+1 && (f=DFS(e.to,min(a,e.cap-e.flow) ) )>0)
            {
                e.flow +=f;
                edges[G[x][i]^1].flow -=f;
                flow +=f;
                a -=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t)
    {
        this->s=s; this->t=t;
        int flow=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow +=DFS(s,INF);
        }
        return flow;
    }
}DC;

int p,n;
int w[maxn];
int s[maxn][maxn];
int d[maxn][maxn];

bool isStart(int x)
{
    for(int i=1;i<=p;i++)
        if(s[x][i]==1)  return false;
    return true;
}

bool isEnd(int x)
{
    for(int i=1;i<=p;i++)
    {
        if(d[x][i]==0)  return false;
    }
    return true;
}

bool connect(int x, int y)
{
    for(int i=1;i<=p;i++)
    {
        if((s[y][i]==1 && d[x][i]==0) ||(s[y][i]==0 && d[x][i]==1))   return false;
    }
    return true;
}

int main()
{
    //freopen("in.txt","r",stdin);
    while(~scanf("%d%d",&p,&n))
    {
        int src=0, dst=2*n+1;
        DC.init(dst+1);

        for(int i=1;i<=n;i++)
        {
            scanf("%d",&w[i]);

            for(int j=1;j<=p;j++)
                scanf("%d",&s[i][j]);
            for(int j=1;j<=p;j++)
                scanf("%d",&d[i][j]);

            if(isStart(i)) DC.AddEdge(src,i,INF);
            if(isEnd(i))  DC.AddEdge(i+n,dst,INF);
        }

        for(int i=1;i<=n;i++)  DC.AddEdge(i,i+n,w[i]);

        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(i==j)  continue;
                if(connect(i,j))   DC.AddEdge(i+n,j,INF);
            }
        }

        int ans=DC.Maxflow(src,dst);

        int cnt=0;
        for(int i=0;i<DC.edges.size();i++)
        {
            Edge& e=DC.edges[i];
            if(e.from==src || e.from==dst || e.to==src || e.to==dst)  continue;
            if((e.from+n)==e.to||(e.from-n)==e.to)  continue;
            if(e.flow<0)  cnt++;
        }
        printf("%d %d
",ans,cnt);

        for(int i=0;i<DC.edges.size();i++)
        {
            Edge& e=DC.edges[i];
            if(e.from==src || e.from==dst || e.to==src || e.to==dst)  continue;
            if((e.from+n)==e.to||(e.from-n)==e.to)  continue;
            if(e.flow<0)
                printf("%d %d %d
",e.to-n,e.from,-e.flow);
        }
    }
    return 0;
}