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[105][15], p, n, q[55];
int G[105][105], G_copy[105][105], layer[105], vis[105];

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

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

int dinic(int s, int e)
{
    int flow = 0;
    deque<int> q;
    while (countLayer(s, e))
    {
        memset(vis, 0, 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 = 0;
                for (int i = 1; i < q.size(); i++)
                {
                    if (G[q[i - 1]][q[i]] && G[q[i - 1]][q[i]] < minn)
                    {
                        minn = G[q[i - 1]][q[i]];
                        min_index = i - 1;
                    }
                }
                for (int i = 1; i < q.size(); i++)
                {
                    G[q[i - 1]][q[i]] -= minn;
                    G[q[i]][q[i - 1]] += minn;
                }
                while (q.size() && q.back() != min_index)
                {
                    vis[q.back()] = false;
                    q.pop_back();
                }
                flow += minn;
            }
            else
            {
                bool flag = false;
                for (int i = 1; i <= e; i++)
                {
                    if (G[tmp][i] && !vis[i] && layer[i] == layer[tmp] + 1)
                    {
                        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 = 0; i < n; i++)
        {
            cin >> q[i];
            for (int j = 0; j < p; j++)
            {
                cin >> g[i][j];
            }
            for (int j = 0; j < p; j++)
            {
                cin >> g[i + n][j];
            }
        }
        memset(G, 0, sizeof(G));
        for (int i = 2; i < n + 2; i++)
        {
            G[i][i + n] = q[i - 2];
        }
        for (int i = 2; i < n + 2; i++)
        {
            bool flag = true;
            for (int j = 0; j < p; j++)
            {
                if (g[i - 2][j] != 0 && g[i - 2][j] != 2)
                {
                    flag = false;
                    break;
                }
            }
            if (flag)
            {
                G[1][i] = INF;
            }
        }
        for (int i = n + 2; i < 2 * n + 2; i++)
        {
            bool flag = true;
            for (int j = 0; j < p; j++)
            {
                if (g[i - 2][j] != 1)
                {
                    flag = false;
                    break;
                }
            }
            if (flag)
            {
                G[i][2 * n + 2] = INF;
            }
        }
        for (int i = n + 2; i < 2 * n + 2; i++)
        {
            for (int j = 2; j < n + 2; j++)
            {
                bool flag = true;
                for (int k = 0; k < p; k++)
                {
                    if (!(g[i - 2][k] == g[j - 2][k] || g[j - 2][k] == 2))
                    {
                        flag = false;
                        break;
                    }
                }
                if (flag)
                {
                    G[i][j] = INF;
                }
            }
        }
        for (int i = 1; i <= 2 * n + 2; i++)
        {
            for (int j = 1; j <= 2 * n + 2; j++)
            {
                G_copy[i][j] = G[i][j];
            }
        }
        cout << dinic(1, 2 * n + 2) << " ";
        int cnt = 0;
        vector<node> v;
        for (int i = n + 2; i < 2 * n + 2; i++)
        {
            for (int j = 2; j < n + 2; j++)
            {
                if (i - n != j && G[i][j] != G_copy[i][j])
                {
                    cnt++;
                    node tmp;
                    tmp.x = i - n - 1;
                    tmp.y = j - 1;
                    tmp.c = G_copy[i][j] - G[i][j];
                    v.push_back(tmp);
                }
            }
        }
        cout << cnt << endl;
        for (int i = 0; i < v.size(); i++)
        {
            cout << v[i].x << " " << v[i].y << " " << v[i].c << endl;
        }
    }
    return 0;
}