Poj 3436 ACM Computer Factory (最大流)

题目链接：

　　Poj 3436 ACM Computer Factory

题目描述：

　　n个工厂，每个工厂能把电脑s态转化为d态，每个电脑有p个部件，问整个工厂系统在每个小时内最多能加工多少台电脑？

解题思路：

　　因为需要输出流水线要经过的工厂路径，如果要用电脑状态当做节点的话，就GG了。所以建图的时候要把工厂当做节点。对于节点i，能生产si电脑的节点可以进入节点i，能转化ei电脑的节点可以由i节点进入。要注意对于每一个节点要进行拆点，防止流量发生错误。

 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int maxn = ;
 const int INF = 0x3f3f3f3f;
 struct node
 {
     int x, s[], e[];
 } mach[maxn];
 struct node1
 {
     int s, e, x;
 } path[maxn*maxn];
 int maps[maxn*][maxn*], Maps[maxn*][maxn*];
 int Layer[maxn*], p, n, num;

 void buildmaps (int s, int e)
 {
     for (int i=s; i<=e; i++)
     {
         int j, k;
         for (int j=s; j<=e; j++)
         {
             if (i == j)
                 continue;
             for (k=; k<p; k++)
             {
                 if (mach[i].e[k]== || mach[j].s[k]==)
                     continue;
                 if (mach[i].e[k] != mach[j].s[k])
                     break;
             }
             if (k == p)
                 {
                     if (i > )
                         Maps[i+n][j] = mach[i].x;
                     else
                         Maps[i][j] = mach[i].x;
                 }
         }
     }

     for (int i=; i<=num; i++)
         for (int j=; j<=num; j++)
         maps[i][j] = Maps[i][j];
 }

 bool CountLayer (int s, int e)
 {
     queue <int> Q;
     memset (Layer, , sizeof(Layer));
     Layer[s] = ;
     Q.push (s);

     while (!Q.empty ())
     {

         int u = Q.front();
         Q.pop();

         for (int i=; i<=num; i++)
             if (!Layer[i] && maps[u][i])
             {
                 Layer[i] = Layer[u] + ;
                 Q.push (i);
                 if (i == e)
                     return true;
             }
     }
     return false;
 }

 int Dfs (int u, int e, int maxflow)
 {
     if (u == e)
         return maxflow;

     int uflow = ;
     for (int i=; i<=num; i++)
     {
         if (maps[u][i] && Layer[i]==Layer[u]+)
         {
             int flow = min(maps[u][i], maxflow - uflow);
             flow = Dfs (i, e, flow);

             uflow += flow;
             maps[u][i] -= flow;
             maps[i][u] += flow;
             if (uflow == maxflow)
                 break;
         }
     }

     if (uflow == )
         Layer[u] = ;

     return uflow;
 }

 int Dinic (int s, int e)
 {
     int maxflow = ;

     while (CountLayer(s, e))
         maxflow += Dfs(s, e, INF);

     return maxflow;
 }

 int main ()
 {
     while (scanf ("%d %d", &p, &n) != EOF)
     {
         memset (mach, , sizeof(mach));
         memset (Maps, , sizeof(Maps));
         mach[].x = INF;
         for (int i=; i<p; i++)
         {
             mach[].s[i] = INF;
             mach[].e[i] = INF;
             mach[].s[i] = ;
         }

         for (int i=; i<n+; i++)
         {
             scanf ("%d", &mach[i].x);
             for (int j=; j<p; j++)
                 scanf ("%d", &mach[i].s[j]);
             for (int j=; j<p; j++)
                 scanf ("%d", &mach[i].e[j]);
             Maps[i][i+n] = mach[i].x;//拆点
         }

         int ans, res;
         res = ;
         num = n + n + ;

         buildmaps (, n+);
         ans = Dinic (, );

         for (int i=; i<num; i++)
         {
             for (int j=; j<num; j++)
             {

                 if (i == j+n || j==i+n)
                     continue;

                 if (Maps[i][j] - maps[i][j] > )
                 {
                     path[res].x = Maps[i][j] - maps[i][j];
                     path[res].s = (i - ) % n + ;
                     path[res++].e = (j - ) % n + ;
                 }

             }
         }

         printf ("%d %d\n", ans, res);
         for (int i=; i<res; i++)
             printf ("%d %d %d\n", path[i].s, path[i].e, path[i].x);

     }
     return ;
 }