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;
}