POJ-3436 ACM Computer Factory---最大流+拆点

题目链接：

https://vjudge.net/problem/POJ-3436

题目大意：

每台电脑有p个组成部分，有n个工厂加工电脑。每个工厂对于进入工厂的半成品的每个组成部分都有要求，由p个数字描述，0代表这个部分不能有，1代表这个部分必须有，2代表这个部分的有无无所谓。每个工厂的产出也不尽相同，也是由p个数字代表，0代表这个部分不存在，1代表这个部分存在。每个工厂都有一个最大加工量。给出这n个工厂的以上数据，求出最多能加工出多少台电脑。

解题思路：

这道题主要是如何建设出网络出来，每个工厂表示一个点

1、首先对每个点进行拆分，拆成i（输入部分）和n+i（输出部分），之间连接一条边，权值为这个点的加工量（拆点这个技巧是为了维护点的权值）

2、对每个点的输入部分（i），如果没有一，那就从超级源点s出发，连一条边到该点，权值为这个点的加工量。（因为只有全是0，或者是0或2没有1，那才是整个工厂的出发点）（此处不要忘记2的存在，一开始只把全是0的和超级源点s建边，后来想到只要没有1，都可以建边）

3、对于每个点的输出部分(n + i)，如果全是1，说明已经建好，和超级汇点建边，权值为这个点的加工量

4、对于每个点的输出部分(n + i)，只要满足其他点的输入部分，这两点之间可以建立边，权值设置成INF（这里设置成INF的目的是为了最后输出答案中的边，便于寻找这些边，只要权值为INF的边且流量不为0，那么这条边就可以输出）

然后就是从源点s到汇点t的最大流（传送门：最大流模板）

 #include<iostream>
 #include<vector>
 #include<cstring>
 #include<queue>
 using namespace std;
 const int maxn =  + ;
 const int INF = 0x3f3f3f3f;
 int n, m;
 struct edge
 {
     int u, v, c, f;
     edge(int u, int v, int c, int f):u(u), v(v), c(c), f(f){}
 };
 vector<edge>e;
 vector<int>Map[maxn];
 int a[maxn], p[maxn];
 void init(int n)
 {
     e.clear();
     for(int i = ; i <= n; i++)Map[i].clear();
 }
 void addedge(int u, int v, int c)
 {
     //cout<<u<<" "<<v<<" "<<c<<endl;
     e.push_back(edge(u, v, c, ));
     e.push_back(edge(v, u, , ));
     int m = e.size();
     Map[u].push_back(m - );
     Map[v].push_back(m - );
 }
 int Maxflow(int s, int t)
 {
     int flow = ;
     for(;;)
     {
         memset(a, , sizeof(a));
         queue<int>q;
         q.push(s);
         a[s]  =INF;
         while(!q.empty())
         {
             int u = q.front();
             q.pop();
             for(int i = ; i < Map[u].size(); i++)
             {
                 edge& now = e[Map[u][i]];
                 int v = now.v;
                 if(!a[v] && now.c > now.f)//还未流经并且边还有容量
                 {
                     p[v] = Map[u][i];
                     a[v] = min(a[u], now.c - now.f);
                     q.push(v);
                 }
             }
             if(a[t])break;//已经到达汇点
         }
         if(!a[t])break;//已经没有增广路
         for(int u = t; u != s; u = e[p[u]].u)
         {
             e[p[u]].f += a[t];
             e[p[u] ^ ].f -= a[t];
         }
         flow += a[t];
     }
     return flow;
 }
 int cnt[maxn][maxn];
 vector<edge>ans;
 int main()
 {
     cin >> m >> n;
     for(int i = ; i <= n; i++)
     {
         for(int j = ; j <=  * m; j++)cin >> cnt[i][j];
     }
     int s = , t =  * n + ;
     for(int i = ; i <= n; i++)
     {
         int tot1 = , tot2 = ;
         for(int j = ; j <= m; j++)tot1 += cnt[i][j] ==  ?  : ;//此处只要没有1，就可以和s建边
         for(int j = m + ; j <=  * m; j++)tot2 += cnt[i][j];//此处全为1就可以和t建边
         addedge(i, i + n, cnt[i][]);
         if(tot1 == )addedge(s, i, cnt[i][]);
         if(tot2 == m)//和t建边之后没必要寻找其他点建边
         {
             addedge(i + n, t, cnt[i][]);
             continue;
         }
         for(int j = ; j <= n; j++)
         {
             if(i == j)continue;
             int flag = ;
             for(int k = ; k <= m; k++)
             {
                 if(cnt[j][k] ==  && cnt[i][m + k] != )//第j个点的第k个值为0，说明不需要第k个元件，那么第i个点的第k原件输出只能为0
                 {
                     flag = ;
                     break;
                 }
                 if(cnt[j][k] ==  && cnt[i][m + k] != )//第j个点的第k个值为1，说明需要第k个元件，那么第i个点的第k原件输出只能为1
                 {
                     flag = ;
                     break;
                 }
             }
             if(flag)addedge(i + n, j, INF);//ij可以建边，设置成INF
         }
     }
     cout<<Maxflow(s, t)<<" ";
     for(int i = ; i < e.size(); i += )//此处+=2，是因为最大流有反向边
     {
         //cout<<e[i].u<<" "<<e[i].v<<" "<<e[i].c<<" "<<e[i].f<<endl;
         if(e[i].c == INF && e[i].f > )
         {
             ans.push_back(e[i]);
         }
     }
     cout<<ans.size()<<endl;
     for(int i = ; i < ans.size(); i++)
     {
         cout<<ans[i].u - n<<" "<<ans[i].v<<" "<<ans[i].f<<endl;
     }
 }