POJ 3436：ACM Computer Factory

题目链接：http://poj.org/problem?id=3436

题目意思：

一台电脑有P个部分（P不超过10），总共有N台生产电脑的机器可以对电脑（添加或拆除一些组件）。

每台机器的工作效率为Q，给出N台机器可接收的电脑的情况，和输出电脑的情况。

则给出P个数：0代表这个部分不能有，1代表这个部分一定要有 ，2代表这个部分可有可无

然后在给出P个数：是其出产的电脑的情况，0代表缺少这个部分，1代表已安装这个部分。

只有P个数全为1才是成品。

最终求最大产量：以及那些机器有合作关系。

就是求最大流和构成最大流的那些边。

解题思路：

首先建立超级源点S和超级汇点D，然后S对于那些接收电脑不需要任何组件的机器建立关系。

D与那些能够生产出成品的机器建立关系。对于同一个机器拆成两点，其流量为该机器的产量。

也有不拆点做的人，也是弄超级源点和超级汇点，如果机器i所产的产品能被机器j加工，则建立

i到j的边，其流量是i，j两个机器中最小的产量。但是这中做法虽然能够AC，这是因为POJ测试

数据不全面，原来我不太明白为什么要拆点，看了别人不拆点的思路，我觉得挺有道理，但是

看到一组测试数据，我就彻底明白了为啥要拆点，感觉最大的作用就是限制了流量。

比如下面这个数据：

2 4

10 0001

10 0000

10 0111

10 0111

不拆点写法答案：20

拆点写法答案：10

正确答案：10

按照那些不拆点人的想法，建图如下：

可见这样执行完算法，求解出答案的确是20，这些机器是同时工作的，就像平时那个流水线一样同步

并行这样的结果必然是不可能出现的实际上。

所以就来看看拆点的写法所构建的图：

所以这个题目拆点来写才是正解。从图中可以看出除了一个机器拆出的两点之间的流量是自身的产量，

其他边的流量都使用INF来表示。

题目还让求出那些边有输送关系。我们可以先保留原图，然后备份原图，在备份的图上计算最大流量，

则备份的图最终留下一个残余网络，则原网络-残余网络大于0的边，二者之间有产品的输送关系。

输送量为两者之差。

EK算法AC代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>

using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 110;
int N,P;              ///N台部件和P个部分
int S,D;              ///超级源点和超级汇点
int cap1[maxn][maxn]; ///在原图上进行求取最大流的操作
int cap2[maxn][maxn]; ///原图备份的图
int pre[maxn];        ///前驱节点
int yield[maxn];      ///每台机器的产量
int input[maxn][15];  ///每台机器可以接收的电脑的情况
int output[maxn][15]; ///每台机器可以输出的电脑的情况
int minFlow[maxn];
int maxFlow;
void Edmonds_Karp()
{
    int u,v;
    maxFlow = 0;
    queue<int>qu;
    while(true)
    {
        memset(minFlow,0,sizeof(minFlow));
        minFlow[S] = INF+1;
        qu.push(S);
        while(!qu.empty())
        {
            u = qu.front();
            qu.pop();
            for(v = 0; v <= 2*N+1; v++)
            {
                if(minFlow[v]==0 && cap1[u][v] != 0)
                {
                    pre[v] = u;
                    qu.push(v);
                    minFlow[v] = min(minFlow[u],cap1[u][v]); ///在此过程中就把S到D路径中的最小流量求出
                }
            }
        }
        if(minFlow[D]==0)  ///不能找到一条S到D的增广路径了
            break;
        maxFlow += minFlow[D];
        for(v = D; v != S; v = pre[v])
        {
            u = pre[v];
            cap1[u][v] -= minFlow[D];
            cap1[v][u] += minFlow[D];
        }
    }
}
int main()
{
    while(~scanf("%d%d",&P,&N))
    {
        for(int i = 1; i <= N; i++)
        {
            scanf("%d",&yield[i]);
            input[i][0] = 1;            ///代表改机器接受的电脑不必需包括任一组件
            for(int j = 1; j <= P; j++)
            {
                scanf("%d",&input[i][j]);
                if(input[i][j] == 1)   
                    input[i][0] = 0;    ///代表该机器接收的电脑必须包含某一组件
            }
            output[i][0] = 1;           ///代表该机器输出的是成品
            for(int j = 1; j <= P; j++)
            {
                scanf("%d",&output[i][j]);
                if(output[i][j] != 1)
                    output[i][0] = 0;  ///代表该机器输出的不是成品。
            }
        }
        memset(cap1,0,sizeof(cap1));    ///原来的图
        memset(cap2,0,sizeof(cap2));    ///复制的图。
        S = 0;
        D = 2*N+1;
        for(int i = 1; i <= N; i++)
        {
            cap1[i][i+N] = cap2[i][i+N] = yield[i];  ///一个点拆成两个点，建立一条边，其流量为该机器的效率。
            if(input[i][0] == 1)                     ///建立0到i的边
            {
                cap1[S][i] = cap2[S][i] = INF;
            }
            ///在此拆点，第i台机器拆成输入、输出两点，编号分别为i,i+N，代表第i台机器可以输出成品，与D建立关系
            if(output[i][0] == 1) 
            {
                cap1[i+N][D] = cap2[i+N][D] = INF;
            }
        }
        for(int i = 1; i <= N; i++)
            for(int j = 1; j <= N; j++)
            {
                if(i != j)
                {
                    bool canConnected = true;  ///设i到j可以建边
                    for(int k = 1; k <= P; k++)
                    {
                        if(output[i][k] + input[j][k] == 1)
                        {
                            canConnected = false;
                            break;
                        }
                    }
                    if(canConnected == true)
                    {
                        cap1[i+N][j] = cap2[i+N][j] = INF;
                    }
                }
            }
            Edmonds_Karp();   ///求最大流后，cap1就是最终残余网络
            ///求解最大流中每条边的流量。
            ///用原图的备份图减去残余网络上的剩余量。
            int ansfrom[maxn];
            int ansto[maxn];
            int ansyield[maxn];
            int cnt = 0;
            for(int i = 1; i <= N; i++)
                for(int j = 1; j <= N; j++)
                {
                    if(i != j)
                    {
                        ///残余网络         原网络备份
                        if(cap1[i+N][j] < cap2[i+N][j])
                        {
                            ansfrom[cnt] = i;
                            ansto[cnt] = j;
                            ansyield[cnt++] = cap2[i+N][j]-cap1[i+N][j];
                        }
                    }
                }
            printf("%d %d\n",maxFlow,cnt);
            for(int i = 0; i < cnt; i++)
            {
                printf("%d %d %d\n",ansfrom[i],ansto[i],ansyield[i]);
            }
    }
    return 0;
}

Dinic算法实现:

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>

using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 110;
int N,P;              ///N台部件和P个部分
int S,D;              ///超级源点和超级汇点
int cap1[maxn][maxn]; ///在原图上进行求取最大流的操作
int cap2[maxn][maxn]; ///原图备份的图
int yield[maxn];      ///每台机器的产量
int input[maxn][15];  ///每台机器可以接收的电脑的情况
int output[maxn][15]; ///每台机器可以输出的电脑的情况
int maxFlow,minFlow,minFlowNode;
int level[maxn];      ///给残余网络的点进行层次编号
int vis[maxn];

///bfs对残余网络中点的层次进行编号
bool bfs()
{
    queue<int>qu;
    memset(level,-1,sizeof(level));
    level[S] = 0;
    qu.push(S);
    while(!qu.empty())
    {
        int u = qu.front();
        qu.pop();
        for(int i = 0; i <= 2*N+1; i++)
        {
            ///节点i还没有被编号，且u到i还有流量
            if(level[i]==-1 && cap1[u][i]>0)
            {
                level[i] = level[u] + 1;
                /**如果到了D，直接结束就可以了，因为按照这个算法，
                再往后走即便又回到D又有什么意义，编号还更深了*/
                if(i == D)  
                    return true;
                qu.push(i);
            }
        }
    }
    return false;  ///代表bfs分层不能成功找到终点
}
///再成功分层的情况下再进行dfs
void dfs()
{
    int u,v,cur,i;
    deque<int>qu;               ///双端队列，当作我们用的栈
    memset(vis,0,sizeof(vis));  ///设置所有点都没有访问过
    qu.push_back(S);
    vis[S] = 1;
    while(!qu.empty())
    {
        cur = qu.back();  ///返回最后一个元素
        if(cur == D)      ///如果到达终点，栈中存放的点是S到D的一条增广路径
        {
            ///找一路走来容量最小的边，以及该边的起点。
            minFlow = INF+1;
            minFlowNode = S;
            for(i = 1; i < qu.size(); i++)
            {
                u = qu[i-1];
                v = qu[i];
                if(cap1[u][v] > 0 && minFlow>cap1[u][v])
                {
                    minFlow = cap1[u][v];
                    minFlowNode = u;
                }
            }
            ///加上增加的流量。
            maxFlow += minFlow;
            for(i = 1; i < qu.size(); i++)
            {
                u = qu[i-1];
                v = qu[i];
                cap1[u][v] -= minFlow;
                cap1[v][u] += minFlow;
            }
            while(!qu.empty() && qu.back() != minFlowNode)
            {
                vis[qu.back()] = 0;
                qu.pop_back();
            }
        }
        else
        {
            for(i = 1; i <= 2*N+1; i++)
            {
                ///cur到i的流量，到更深一层找一个未访问的节点。
                if(cap1[cur][i]>0 && level[i] == level[cur]+1 && vis[i]==0)
                {
                    vis[i] = 1;
                    qu.push_back(i);
                    break;
                }
            }
            if(i > 2*N+1)  ///找不到
                qu.pop_back();
        }
    }
}
void dinic()
{
    maxFlow = 0;
    while(bfs())  ///如果bfs还能分层最终找到D点
    {
        dfs();
    }
}
int main()
{
    while(~scanf("%d%d",&P,&N))
    {
        for(int i = 1; i <= N; i++)
        {
            scanf("%d",&yield[i]);
            input[i][0] = 1;            ///代表改机器接受的电脑不必需包括任一组件
            for(int j = 1; j <= P; j++)
            {
                scanf("%d",&input[i][j]);
                if(input[i][j] == 1)
                    input[i][0] = 0;    ///代表该机器接收的电脑必须包含某一组件
            }
            output[i][0] = 1;           ///代表该机器输出的是成品
            for(int j = 1; j <= P; j++)
            {
                scanf("%d",&output[i][j]);
                if(output[i][j] != 1)
                    output[i][0] = 0;  ///代表该机器输出的不是成品。
            }
        }
        memset(cap1,0,sizeof(cap1));    ///原来的图
        memset(cap2,0,sizeof(cap2));    ///复制的图。
        S = 0;
        D = 2*N+1;
        for(int i = 1; i <= N; i++)
        {
            cap1[i][i+N] = cap2[i][i+N] = yield[i];  ///一个点拆成两个点，建立一条边，其流量为该机器的效率。
            if(input[i][0] == 1)                     ///建立0到i的边
            {
                cap1[S][i] = cap2[S][i] = INF;
            }
            ///在此拆点，第i台机器拆成输入、输出两点，编号分别为i,i+N，代表第i台机器可以输出成品，与D建立关系
            if(output[i][0] == 1)
            {
                cap1[i+N][D] = cap2[i+N][D] = INF;
            }
        }
        for(int i = 1; i <= N; i++)
            for(int j = 1; j <= N; j++)
            {
                if(i != j)
                {
                    bool canConnected = true;  ///设i到j可以建边
                    for(int k = 1; k <= P; k++)
                    {
                        if(output[i][k] + input[j][k] == 1)
                        {
                            canConnected = false;
                            break;
                        }
                    }
                    if(canConnected == true)
                    {
                        cap1[i+N][j] = cap2[i+N][j] = INF;
                    }
                }
            }
            ///求解最大流中每条边的流量。
            ///用原图的备份图减去残余网络上的剩余量。
            dinic();
            int ansfrom[maxn];
            int ansto[maxn];
            int ansyield[maxn];
            int cnt = 0;
            for(int i = 1; i <= N; i++)
                for(int j = 1; j <= N; j++)
                {
                    if(i != j)
                    {
                        ///残余网络         原网络备份
                        if(cap1[i+N][j] < cap2[i+N][j])
                        {
                            ansfrom[cnt] = i;
                            ansto[cnt] = j;
                            ansyield[cnt++] = cap2[i+N][j]-cap1[i+N][j];
                        }
                    }
                }
            printf("%d %d\n",maxFlow,cnt);
            for(int i = 0; i < cnt; i++)
            {
                printf("%d %d %d\n",ansfrom[i],ansto[i],ansyield[i]);
            }
    }
    return 0;
}