POJ3436

题目链接：http://poj.org/problem?id=3436

题目大意：

　　一台电脑可以分成P个部分，在生产过程中，半成品电脑有的部分已经完成（记为1），而有的部分还没有完成（记为0）。电脑生产商用N台机器生产电脑，对于放入各台机器的电脑，各自有其要求，即有些部分必须已经完成（记为1），有些部分必须还未完成（记为0），有些部分是否完成无关紧要（记为2），求怎么安排生产线使工厂的总生产效率最高。

解题思路：

　　最大流问题。

　　首先是建图。如果某台机器对于放入其中的电脑的要求全为0或者2，那么这台机器就是一个源点，如果某台机器生产出的电脑所有部分都为1，那么这台机器就可以看成一个汇点。这样就有多个源点和多个汇点，那么我们可以设置一个超级源点和超级汇点，超级源点指向每一个源点，每一个汇点指向超级汇点，流量限制为inf。对于每一台机器，为了表示其效率上限，我们将其拆成两个点，表示入口和出口，中间用一条流量限制为机器生存效率的线连接。而对于不同的机器，如果一台机器生产出来的电脑能够送往另一台电脑，那么就将这台机器的出口指向另一台机器的入口，流量限制为inf。建图完成，其他的交给模板。

　　另一个难点是要printf出最大流经过的路径。那么我们就可以来研究模板跑完以后留下的残量网络。首先有三种路是我们为了方便解决问题而加入的，printf路径的时候必须无视掉：从超级源点流出的路，流入超级汇点的路，由机器入口流到出口的路。那么对于剩下的路，如果路上流量大于0，（或者说残量小于流量限制），那么这条路就是我们这个最大流网络中会经过的，打印出起点、终点和流量即可。

AC代码：

 #include <iostream>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <queue>
 using namespace std;
 const int inf = 0x7ffffff, maxn =  + ;
 struct node {
     int s[], t[];
     int v;
 }machine[];
 //模板作者：刘汝佳
 //**************************************************
 struct ans {
     int from, to, num;
 }ret[maxn];
 struct Edge {
     int from, to, cap, flow;
     Edge(int u, int v, int c, int f) :from(u), to(v), cap(c), flow(f) {}
 };
 vector<int>ans[maxn];
 int len = , dis[maxn][maxn];
 struct Dinic {
     int n, m, s, t;
     vector<Edge> edges;
     vector<int> G[maxn];
     bool vis[maxn];
     int d[maxn];
     int cur[maxn];

     void init(int n) {
         this->n = n;
         for (int i = ; i < n; i++)    G[i].clear();
         edges.clear();
     }
     void addedge(int from, int to, int cap) {
         edges.push_back(Edge(from, to, cap, ));
         edges.push_back(Edge(to, from, , ));
         m = edges.size();
         G[from].push_back(m - );
         G[to].push_back(m - );
     }
     bool BFS() {
         memset(vis, , sizeof(vis));
         queue<int> Q;
         Q.push(s);
         d[s] = ;
         vis[s] = ;
         while (!Q.empty()) {
             int x = Q.front();    Q.pop();
             for (int i = ; i < G[x].size(); i++) {
                 Edge &e = edges[G[x][i]];
                 if (!vis[e.to] && e.cap>e.flow) {
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x, int a) {
         if (x == t || a == )    return a;
         int flow = , f;
         for (int &i = cur[x]; i < G[x].size(); i++) {
             Edge &e = edges[G[x][i]];
             if (d[x] +  == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow)))>) {
                 e.flow += f;
                 edges[G[x][i] ^ ].flow -= f;
                 flow += f;
                 a -= f;
                 if (a == )    break;
             }
         }
         return flow;
     }
     int Maxflow(int s, int t) {
         this->s = s;    this->t = t;
         int flow = ;
         while (BFS()) {
             memset(cur, , sizeof(cur));
             flow += DFS(s, inf);
         }
         return flow;
     }
 };
 //****************************************************
 int main() {
     //    freopen("in.txt","r",stdin);
     int P, N;
     Dinic temp;
     scanf("%d%d", &P, &N);
     temp.init( * N + );
     for (int i = ; i <= N; i++) {
         scanf("%d", &machine[i].v);
         for (int j = ; j<P; j++)    scanf("%d", &machine[i].s[j]);
         for (int j = ; j<P; j++)    scanf("%d", &machine[i].t[j]);
         bool sour = true;
         for (int j = ; j<P; j++) {
             if (machine[i].s[j] == ) {
                 sour = false;
                 break;
             }
         }
         if (sour)    temp.addedge(, i, inf);
         bool ending = true;
         for (int j = ; j<P; j++) {
             if (machine[i].t[j] != ) {
                 ending = false;
                 break;
             }
         }
         if (ending)  temp.addedge(i + N,  * N + , inf);
         temp.addedge(i, i + N, machine[i].v);
     }
     for (int i = ; i <= N; i++) {
         for (int j = i + ; j <= N; j++) {
             bool yes1 = true, yes2 = true;
             for (int k = ; k<P; k++) {
                 if (machine[i].t[k]) {
                     if (machine[j].s[k] == )  yes1 = false;
                 }
                 else {
                     if (machine[j].s[k] == )  yes1 = false;
                 }
                 if (machine[j].t[k]) {
                     if (machine[i].s[k] == )  yes2 = false;
                 }
                 else {
                     if (machine[i].s[k] == )  yes2 = false;
                 }
                 if (!yes1&&!yes2)    break;
             }
             if (yes1)
                 temp.addedge(i + N, j, inf);
             if (yes2)
                 temp.addedge(j + N, i, inf);
         }
     }
     printf("%d ", temp.Maxflow(,  * N + ));
     int cnt = ;

     for (int i = ; i<temp.edges.size(); i++) {
         Edge t = temp.edges[i];
         int fw = t.flow, f = t.from, tt = t.to;
         if (fw <=  || t.cap ==  || t.cap != inf || tt>N || f<)  continue;
         ret[cnt].from = f - N, ret[cnt].to = tt, ret[cnt].num = fw;
         cnt++;
     }
     printf("%d\n", cnt);
     for (int i = ; i<cnt; i++) {
         printf("%d %d %d\n", ret[i].from, ret[i].to, ret[i].num);
     }
     return ;
 }