Poj 3436 ACM Computer Factory (最大流)

题目链接：

　　Poj 3436 ACM Computer Factory

题目描述：

　　n个工厂，每个工厂能把电脑s态转化为d态，每个电脑有p个部件，问整个工厂系统在每个小时内最多能加工多少台电脑？

解题思路：

　　因为需要输出流水线要经过的工厂路径，如果要用电脑状态当做节点的话，就GG了。所以建图的时候要把工厂当做节点。对于节点i，能生产si电脑的节点可以进入节点i，能转化ei电脑的节点可以由i节点进入。要注意对于每一个节点要进行拆点，防止流量发生错误。

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int maxn = 55;
const int INF = 0x3f3f3f3f;
struct node
{
    int x, s[20], e[20];
} mach[maxn];
struct node1
{
    int s, e, x;
} path[maxn*maxn];
int maps[maxn*2][maxn*2], Maps[maxn*2][maxn*2];
int Layer[maxn*2], p, n, num;

void buildmaps (int s, int e)
{
    for (int i=s; i<=e; i++)
    {
        int j, k;
        for (int j=s; j<=e; j++)
        {
            if (i == j)
                continue;
            for (k=0; k<p; k++)
            {
                if (mach[i].e[k]==2 || mach[j].s[k]==2)
                    continue;
                if (mach[i].e[k] != mach[j].s[k])
                    break;
            }
            if (k == p)
                {
                    if (i > 1)
                        Maps[i+n][j] = mach[i].x;
                    else
                        Maps[i][j] = mach[i].x;
                }
        }
    }
    
    for (int i=0; i<=num; i++)
        for (int j=0; j<=num; j++)
        maps[i][j] = Maps[i][j];
}

bool CountLayer (int s, int e)
{
    queue <int> Q;
    memset (Layer, 0, sizeof(Layer));
    Layer[s] = 1;
    Q.push (s);
    
    while (!Q.empty ())
    {
        
        int u = Q.front();
        Q.pop();
        
        for (int i=0; i<=num; i++)
            if (!Layer[i] && maps[u][i])
            {
                Layer[i] = Layer[u] + 1;
                Q.push (i);
                if (i == e)
                    return true;
            }
    }
    return false;
}

int Dfs (int u, int e, int maxflow)
{
    if (u == e)
        return maxflow;
        
    int uflow = 0;
    for (int i=0; i<=num; i++)
    {
        if (maps[u][i] && Layer[i]==Layer[u]+1)
        {
            int flow = min(maps[u][i], maxflow - uflow);
            flow = Dfs (i, e, flow);

            uflow += flow;
            maps[u][i] -= flow;
            maps[i][u] += flow;
            if (uflow == maxflow)
                break;
        }
    }
        
    if (uflow == 0)
        Layer[u] = 0;
    
    return uflow;
}

int Dinic (int s, int e)
{
    int maxflow = 0;
    
    while (CountLayer(s, e))
        maxflow += Dfs(s, e, INF);
        
    return maxflow;
}

int main ()
{
    while (scanf ("%d %d", &p, &n) != EOF)
    {
        memset (mach, 0, sizeof(mach));
        memset (Maps, 0, sizeof(Maps));
        mach[0].x = INF;
        for (int i=0; i<p; i++)
        {
            mach[0].s[i] = INF;
            mach[1].e[i] = INF;
            mach[1].s[i] = 1;
        }
        
        for (int i=2; i<n+2; i++)
        {
            scanf ("%d", &mach[i].x);
            for (int j=0; j<p; j++)
                scanf ("%d", &mach[i].s[j]);
            for (int j=0; j<p; j++)
                scanf ("%d", &mach[i].e[j]);
            Maps[i][i+n] = mach[i].x;//拆点
        }
        
        int ans, res;
        res = 0;
        num = n + n + 1;
        
        buildmaps (0, n+1);
        ans = Dinic (0, 1);
        
        for (int i=2; i<num; i++)
        {
            for (int j=2; j<num; j++)
            {
                
                if (i == j+n || j==i+n)
                    continue;
                    
                if (Maps[i][j] - maps[i][j] > 0)
                {
                    path[res].x = Maps[i][j] - maps[i][j];
                    path[res].s = (i - 2) % n + 1;
                    path[res++].e = (j - 2) % n + 1;
                }
                
            }
        }
        
        printf ("%d %d
", ans, res);
        for (int i=0; i<res; i++)
            printf ("%d %d %d
", path[i].s, path[i].e, path[i].x);
            
    }
    return 0;
}