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 = 100 + 10;
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 = 0; 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, 0));
    e.push_back(edge(v, u, 0, 0));
    int m = e.size();
    Map[u].push_back(m - 2);
    Map[v].push_back(m - 1);
}
int Maxflow(int s, int t)
{
    int flow = 0;
    for(;;)
    {
        memset(a, 0, sizeof(a));
        queue<int>q;
        q.push(s);
        a[s]  =INF;
        while(!q.empty())
        {
            int u = q.front();
            q.pop();
            for(int i = 0; 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] ^ 1].f -= a[t];
        }
        flow += a[t];
    }
    return flow;
}
int cnt[maxn][maxn];
vector<edge>ans;
int main()
{
    cin >> m >> n;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 0; j <= 2 * m; j++)cin >> cnt[i][j];
    }
    int s = 0, t = 2 * n + 1;
    for(int i = 1; i <= n; i++)
    {
        int tot1 = 0, tot2 = 0;
        for(int j = 1; j <= m; j++)tot1 += cnt[i][j] == 1 ? 1 : 0;//此处只要没有1，就可以和s建边
        for(int j = m + 1; j <= 2 * m; j++)tot2 += cnt[i][j];//此处全为1就可以和t建边
        addedge(i, i + n, cnt[i][0]);
        if(tot1 == 0)addedge(s, i, cnt[i][0]);
        if(tot2 == m)//和t建边之后没必要寻找其他点建边
        {
            addedge(i + n, t, cnt[i][0]);
            continue;
        }
        for(int j = 1; j <= n; j++)
        {
            if(i == j)continue;
            int flag = 1;
            for(int k = 1; k <= m; k++)
            {
                if(cnt[j][k] == 0 && cnt[i][m + k] != 0)//第j个点的第k个值为0，说明不需要第k个元件，那么第i个点的第k原件输出只能为0
                {
                    flag = 0;
                    break;
                }
                if(cnt[j][k] == 1 && cnt[i][m + k] != 1)//第j个点的第k个值为1，说明需要第k个元件，那么第i个点的第k原件输出只能为1
                {
                    flag = 0;
                    break;
                }
            }
            if(flag)addedge(i + n, j, INF);//ij可以建边，设置成INF
        }
    }
    cout<<Maxflow(s, t)<<" ";
    for(int i = 0; i < e.size(); i += 2)//此处+=2，是因为最大流有反向边
    {
        //cout<<e[i].u<<" "<<e[i].v<<" "<<e[i].c<<" "<<e[i].f<<endl;
        if(e[i].c == INF && e[i].f > 0)
        {
            ans.push_back(e[i]);
        }
    }
    cout<<ans.size()<<endl;
    for(int i = 0; i < ans.size(); i++)
    {
        cout<<ans[i].u - n<<" "<<ans[i].v<<" "<<ans[i].f<<endl;
    }
}