poj 3436 ACM Computer Factory 最大流+记录路径

题目

题意：

每一个机器有一个物品最大工作数量，还有一个对什么物品进行加工，加工后的物品是什么样。给你无限多个初始都是000....的机器，你需要找出来经过这些机器操作后最多有多少成功的机器(111.....)

题解：

st是网络流起始点，en是终止点

首先肯定是要拆点的，因为题目上给出的是每一个机器的最大加工数量。这是对于机器本身，所以拆点之后i->start和i->last这条边的容量就是机器的最大加工数量

这个题的话建图很清晰，只要它要加工的原始物品是000...类型的，它就可以和st建一条边，容量无限大。如果加工后的物品是111...这种类型的，那么就可以让这个i->last和en建一条边，容量都是无限大

之后的话如果某个机器加工后的产品可以作为某个机器的原料，那就让他们之间连一条容量无限大的边。这里要注意，当某个机器接受的原料某个部件为2，那这个位置有没有部件都可以连边

例：1机器原料为1 2 1，那么1 0 1和1 1 1的产品他都可以接收

因为题目要求最后要输出那两个机器之间有流量，所以只要跑完最大流之后一个一个点的去检查。发现这个点和其他点之间有流量，那就出输出它.因为在跑最大流的过程中如果找到一条增广路，那么这条可行路上所有边的流量都要减少，就是通过这一点来判断的(具体看代码)

代码：

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
#define INF 99999999
using namespace std;
const int N = 150;
int p,n,cnt;
int capacity[N],m[N][N],head[N],cur[N],d[N];

struct edge
{
    int u,v,c,flow,next;
} e[N*N];
struct shudui
{
    int u,v,w;
}que[N*N];
void adde(int u,int v,int w,int f)
{
    e[cnt].v=v;
    e[cnt].u=u;
    e[cnt].c=w;
    e[cnt].flow=f;
    e[cnt].next=head[u];
    head[u]=cnt++;
}
bool bfs(int s,int t)
{
    for(int i=0; i<=2*n+2; i++) d[i]=0;
    d[s]=1;
    queue <int > q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u]; i!=-1; i=e[i].next)
        {
            int v=e[i].v;
            if(!d[v] && e[i].c>e[i].flow)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[t]!=0;
}
int dfs(int s,int a)
{
    if(s==2*n+1 || a==0) return a;
    int flow = 0;
    for(int &i=cur[s]; i!=-1; i=e[i].next)
    {
        int v=e[i].v,f;
        if(d[v]!=d[s]+1) continue ;
        f=dfs(v,min(a,e[i].c-e[i].flow));
        if(f)
        {
            e[i].flow+=f;
            e[i^1].flow-=f;
            a-=f;
            flow+=f;
            if(a==0) break;
        }
    }
    if(!flow) d[s]=-1;
    return flow;
}
int main()
{
    scanf("%d%d",&p,&n);
    memset(head,-1,sizeof(head));
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&capacity[i]);
        for(int j=1; j<=2*p; j++) scanf("%d",&m[i][j]);
    }

    for(int i=1; i<=n; i++)
    {
        adde(i,i+n,capacity[i],0);
        adde(i+n,i,0,0);
        int flag1=1,flag2=1;
        for(int j=1; j<=p; j++)
        {
            if(m[i][j]==1) flag1=0;
            if(m[i][j+p]!=1) flag2=0;
        }
        if(flag1) adde(0,i,INF,0),adde(i,0,0,0);
        if(flag2) adde(i+n,2*n+1,INF,0),adde(2*n+1,i+n,0,0);
    }
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)  //这里j的初始值不能是i+1,卧槽！！
        {
            if(i==j) continue ;
            bool ok = true ;
            for(int k=p+1; k<=p*2; k++)
            {
                int now = k-p;
                if(m[j][now]==2) continue ;
                if(m[i][k]!=m[j][now]) ok=false;
            }
            if(ok)
            {
                adde(i+n,j,INF,0);
                adde(j,i+n,0,0);
            }
        }
    }
    int max_flow = 0;
    while(bfs(0,2*n+1))
    {
        for(int i=0; i<=2*n+1; i++) cur[i]=head[i];
        max_flow+=dfs(0,INF);
    }
    printf("%d ",max_flow);
    int ans=0;
    for(int i=1+n; i<=2*n; i++)  //如果两个点之间有合作关系，那么他们的e[j].flow肯定不会为0，就是利用这一点找出来所有有合作关系的
    {  //点。题目没有要求怎么输出，那就随便输出就可以
        for(int j=head[i]; j!=-1; j=e[j].next)
        {
            int v=e[j].v;
            if(v!=2*n+1 && v!=0 && e[j].flow && v!=i-n)
            {
                que[ans].u=i-n;
                que[ans].v=v;
                que[ans].w=e[j].flow;
                ans++;
            }
        }
    }
    printf("%d
",ans);
    for(int i=0;i<ans;++i)
    {
        printf("%d %d %d
",que[i].u,que[i].v,que[i].w);
    }
    return 0;
}