POJ 3436 ACM Computer Factory 构图最大流

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

觉得构图  输入 比较纠结

题意：电脑由P部分组成，由N台机器组装，每台机器单位时间有最大组装数，2~N+1行 每行第一个数是  对应机器的最大组装数，接下来P个数是 该机器组装前需要的P个部分（0表示

不需要，1表示不可缺少，2表示有和没有均可）  后P个数表示该机器加工完后，会得到哪些部分（0表示不会到的，1表示一定会得到）

 

增加源点和汇点  纠结在各个机器之间的连接。  首先，输入部件没有1的（为0或2！！！)的与源点相连，权值为该机器的组装数， 输出部件全为一的与汇点相连，权值为

该机器的组装数； 如果一个机器的输出满足另一个机器的输入，连接这两个机器，权值为两机器中的最小值。 构图完成就是  最大流了  我只会dinic一种方法。

还有注意机器间流量输出的实现  cp[i][j]>map[i[j]则  i ->j  有流量

 

代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<queue>
#define Min(a,b)a<b?a:b
#define inf 1<<30
using namespace std;
int val[52],bef[52][12],late[52][12],beg[52],end[52];
int map[52][52],cp[52][52];
int OUT[60][3];
int level[52];
int n,p,SUM;

int dfs(int x,int Cap)
{
    if(x==n+1)
        return Cap;



    int i,temp,tt,y=0;
    for(i=1;i<=n+1;i++)
    {
        if(level[i]==level[x]+1&&Cap>y&&map[x][i]>0)
        {
            temp=Min(Cap-y,map[x][i]);
            if(temp==0)continue;
            tt=dfs(i,temp);
            map[x][i]-=tt;
            map[i][x]+=tt;
            y+=tt;

        }
    }
    return y;
}

int bfs()
{
   int tt,k;
   queue<int>qu;
   memset(level,-1,sizeof(level));
   level[0]=0;
   qu.push(0);
   while(!qu.empty())
   {
       tt=qu.front();
       qu.pop();
       for(k=1;k<=n+1;k++)
           if(map[tt][k]>0&&level[k]==-1)
           {
               level[k]=level[tt]+1;
               qu.push(k);
           }
   }
   if(level[n+1]!=-1)return 1;
   else return 0;
}
void dinic()
{
    SUM=0;
    while(bfs())
    {
        SUM+=dfs(0,inf);
    }
}

int main()
{
    int i,j,k,Sum;
    bool fg;
    while(cin>>p>>n)
    {

        memset(map,0,sizeof(map));
        //memset(sc,0,sizeof(sc));
        //memset(fi,0,sizeof(fi));

        for(i=1;i<=n;i++)
        {
            cin>>val[i];
            Sum=0;

            fg=true;
            for(j=1;j<=p;j++)
            {
                cin>>bef[i][j];
                if(bef[i][j]==1)
                   fg=false;
            }
            if(fg)
                map[0][i]=val[i];


            fg=true;
            for(j=1;j<=p;j++)
            {
                cin>>late[i][j];
                if(late[i][j]==0)
                   fg=false;
            }
            if(fg)
                map[i][n+1]=val[i];
        }
       bool flag;
       for(i=1;i<=n;i++)
       {
           for(j=1;j<=n;j++)
           {
              if(i==j)continue;
              flag=true;
              for(k=1;k<=p;k++)
                  if(bef[j][k]+late[i][k]==1)//bef[j][k]==1&&late[i][k]!=1
                  {
                      flag=false;
                      break;
                  }
              if(flag)
                  map[i][j]=Min(val[i],val[j]);

           }
       }
        memcpy(cp,map,sizeof(map));

      dinic();
      int M=0;
      for(i=1;i<=n;i++)
         for(j=1;j<=n;j++)
         {
             if(cp[i][j]>map[i][j])
             {
                 M++;
                 OUT[M][0]=i;
                 OUT[M][1]=j;
                 OUT[M][2]=cp[i][j]-map[i][j];
             }
         }
          cout<<SUM<<" "<<M<<endl;
      for(i=1;i<=M;i++)
          cout<<OUT[i][0]<<" "<<OUT[i][1]<<" "<<OUT[i][2]<<endl;

    }
    return 0;
}