poj3436 Computer Factory

题意：

电脑公司生产电脑有N个机器，每个机器单位时间产量为Qi。 电脑由P个部件组成，每个机器工作时只能把有某些部件的半成品电脑(或什么都没有的空电脑）变成有另一些部件的半成品电脑或完整电脑(也可能移除某些部件）。求电脑公司的单位时间最大产量，以及哪些机器有协作关系，即一台机器把它的产品交给哪些机器加工。

Sample input

3 4

15 0 0 0 0 1 0

10 0 0 0 0 1 1

30 0 1 2 1 1 1
3   0 2 1 1 1 1

Sample output

25 2

1 3 15

2 3 10

输入：电脑由3个部件组成，共有4台机器，1号机器产量15, 能给空电脑加上2号部件，2号 机器能给空电脑加上2号部件和3号部件, 3号机器能把有1个2号部件和3号部件有无均可的电脑变成成品（每种部件各有一个）
输出：单位时间最大产量25,有两台机器有协作关系，
1号机器单位时间内要将15个电脑给3号机器加工
2号机器单位时间内要将10个电脑给3号机器加工

思路：

网络流模型：

1) 添加一个原点S,S提供最初的原料 00000...
2) 添加一个汇点T, T接受最终的产品 11111...
3) 将每个机器拆成两个点: 编号为i的接收节点，和编号为i+n的产出节点（n是机器数目），前者用于接收原料，后者用于提供加工后的半成品或成品。这两个点之间要连一条边，容量为单位时间产量Qi
4) S 连边到所有接收 "0000..." 或 "若干个0及若干个2" 的机器，容量为无穷大
5) 产出节点连边到能接受其产品的接收节点，容量无穷大
6) 能产出成品的节点，连边到T，容量无穷大。
7) 求S到T的最大流

实现：

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

 const int INF = 0x3f3f3f3f;

 int g[][], p, n, q[];
 int G[][], G_copy[][], layer[], vis[];

 struct node
 {
     int x, y, c;
 };

 bool countLayer(int s, int e)
 {
     layer[s] = ;
     queue<int> q;
     q.push(s);
     memset(vis, , sizeof(vis));
     vis[s] = true;
     while (!q.empty())
     {
         int tmp = q.front();
         q.pop();
         for (int i = ; i <= e; i++)
         {
             if (G[tmp][i] && !vis[i])
             {
                 layer[i] = layer[tmp] + ;
                 if (i == e)
                 {
                     return true;
                 }
                 vis[i] = true;
                 q.push(i);
             }
         }
     }
     return false;
 }

 int dinic(int s, int e)
 {
     int flow = ;
     deque<int> q;
     while (countLayer(s, e))
     {
         memset(vis, , sizeof(vis));
         vis[s] = true;
         q.push_back(s);
         while (!q.empty())
         {
             int tmp = q.back();
             if (tmp == e)
             {
                 int minn = INF;
                 int min_index = ;
                 for (int i = ; i < q.size(); i++)
                 {
                     if (G[q[i - ]][q[i]] && G[q[i - ]][q[i]] < minn)
                     {
                         minn = G[q[i - ]][q[i]];
                         min_index = i - ;
                     }
                 }
                 for (int i = ; i < q.size(); i++)
                 {
                     G[q[i - ]][q[i]] -= minn;
                     G[q[i]][q[i - ]] += minn;
                 }
                 while (q.size() && q.back() != min_index)
                 {
                     vis[q.back()] = false;
                     q.pop_back();
                 }
                 flow += minn;
             }
             else
             {
                 bool flag = false;
                 for (int i = ; i <= e; i++)
                 {
                     if (G[tmp][i] && !vis[i] && layer[i] == layer[tmp] + )
                     {
                         vis[i] = true;
                         q.push_back(i);
                         flag = true;
                         break;
                     }
                 }
                 if (!flag && q.size())
                 {
                     q.pop_back();
                 }
             }
         }
     }
     return flow;
 }

 int main()
 {
     while (cin >> p >> n)
     {
         for (int i = ; i < n; i++)
         {
             cin >> q[i];
             for (int j = ; j < p; j++)
             {
                 cin >> g[i][j];
             }
             for (int j = ; j < p; j++)
             {
                 cin >> g[i + n][j];
             }
         }
         memset(G, , sizeof(G));
         for (int i = ; i < n + ; i++)
         {
             G[i][i + n] = q[i - ];
         }
         for (int i = ; i < n + ; i++)
         {
             bool flag = true;
             for (int j = ; j < p; j++)
             {
                 if (g[i - ][j] !=  && g[i - ][j] != )
                 {
                     flag = false;
                     break;
                 }
             }
             if (flag)
             {
                 G[][i] = INF;
             }
         }
         for (int i = n + ; i <  * n + ; i++)
         {
             bool flag = true;
             for (int j = ; j < p; j++)
             {
                 if (g[i - ][j] != )
                 {
                     flag = false;
                     break;
                 }
             }
             if (flag)
             {
                 G[i][ * n + ] = INF;
             }
         }
         for (int i = n + ; i <  * n + ; i++)
         {
             for (int j = ; j < n + ; j++)
             {
                 bool flag = true;
                 for (int k = ; k < p; k++)
                 {
                     if (!(g[i - ][k] == g[j - ][k] || g[j - ][k] == ))
                     {
                         flag = false;
                         break;
                     }
                 }
                 if (flag)
                 {
                     G[i][j] = INF;
                 }
             }
         }
         for (int i = ; i <=  * n + ; i++)
         {
             for (int j = ; j <=  * n + ; j++)
             {
                 G_copy[i][j] = G[i][j];
             }
         }
         cout << dinic(,  * n + ) << " ";
         int cnt = ;
         vector<node> v;
         for (int i = n + ; i <  * n + ; i++)
         {
             for (int j = ; j < n + ; j++)
             {
                 if (i - n != j && G[i][j] != G_copy[i][j])
                 {
                     cnt++;
                     node tmp;
                     tmp.x = i - n - ;
                     tmp.y = j - ;
                     tmp.c = G_copy[i][j] - G[i][j];
                     v.push_back(tmp);
                 }
             }
         }
         cout << cnt << endl;
         for (int i = ; i < v.size(); i++)
         {
             cout << v[i].x << " " << v[i].y << " " << v[i].c << endl;
         }
     }
     return ;
 }