直接用bfs来求最大流 poj3436

poj3436
求最大流的问题
虚拟出一个源点 和汇点
然后把输入都为0或者2的机器和源点相连接
把输出都为1的机器和汇点相连接
然后根据机器之间的信息把各个机器的输出和输入相链接
这里值得注意的是 每台机器的输入和输出之间也有链接 大小为每台机器每小时的产量

#include <iostream>
#include <deque>
#include <algorithm>
#include <vector>
using namespace std;
const int MAXP = 12;//最大的部件数目
const int MAXM = 100;//最大的机器的数目
const int INF = 0xffffff;
int G[MAXM][MAXM];
int input[MAXM][2 * MAXP + 1];//用来存储输入
int p, m,e;
int layer[MAXM + 2];
int visit[MAXM + 2];
vector<int> a;
vector<int> b;
vector<int> c;
//源点为1节点 m+2为汇点 2~m+1为机器
void insert(int s, int e,int w)
{
    bool sameflag = false;
    for (int i = 0; i < a.size(); i++)
    {
        if (a[i] == s&&b[i] == e)//如果出现了同一对点 则增加这对点的流量
        {
            sameflag = true;
            c[i] += w;
        }
    }
    if (!sameflag)//没有找到相同的点对 则添加进向量里
    {
        a.push_back(s);
        b.push_back(e);
        c.push_back(w);
    }

}
void output()
{

    for (int i = 0; i < a.size(); i++)
    {

            cout << a[i] << " " << b[i] << " " << c[i] << endl;


    }
    a.clear();
    b.clear();
    c.clear();
}

void constructGraph()
{
    memset(G, 0, sizeof(G));//将图清0
    //构造机器内部的链接
    for (int i = 1; i <= m; i++)
    {
        G[2 * i][2 * i + 1] = input[i][0];
    }
    //构造源点和m台机器的链接
    for (int i = 1; i <= m; i++)//扫描m台机器的输入
    {
        bool flag = true;//i编号的机器与源点链接成功的标志
        for (int j = 1; j <= p; j++)
        {
            if (input[i][j] == 1)//如果出现1则说明需要这个part 则不可以和源点相链接
                flag = false;
        }
        if (flag ==true)
            G[1][2*i] = input[i][0];//i机器和源点链接的最大流为这台机器的吞吐量
    }
    //构造m台机器和汇点的链接
    for (int i = 1; i <= m; i++)//扫描m台机器
    {
        bool flag = true;
        for (int j = p+1; j <= 2 * p; j++)//检测i机器的输出是否都为1
        {
            if (input[i][j] != 1)
                flag = false;
        }
        if (flag == true)
            G[2*i+1][2*m + 2] = input[i][0];//i机器和汇点的链接的最大流为这台机器的吞吐量
    }
    //构造m台机器的外部链接
    for (int i = 1; i <= m; i++)//扫描所有可能的配对情况 i为输出机器 j为输入机器
        for (int j = 1; j <= m; j++)
        {
            if (i != j)
            {
                bool flag = true;
                for (int k = 1; k <= p; k++)//检出所有的输入和输出
                {
                    if ((input[j][k] == 0 && input[i][k + p] != 0) || (input[j][k] == 1 && input[i][k + p] != 1))
                        flag = false;
                }
                if (flag == true)G[2*i + 1][2*j] = INF;
            }

        }
}
int EdmondsKarp()
{
    int sum = 0;
    bool findend;//找到汇点的标志
    deque<int>q;
    int p[2 * MAXM];//存放bfs的前驱节点
    int visit[MAXM];//访问标志位
    while (1)
    {
        findend = false;
        memset(visit, 0, sizeof(visit));
        q.clear();
        q.push_back(1);
        visit[1] = 1;
        p[1] = 1;
        while (!q.empty())
        {
            int temp = q.front();
            q.pop_front();
            if (temp == e)//找到了汇点
            {
                int min = INF;
                for (int i = temp; i != 1; i = p[i])//寻找最小的增量
                    if (min >G[p[i]][i])
                        min = G[p[i]][i];
                for (int i = temp; i != 1; i = p[i])//更新图和插入 在增广路径上的所有点
                {
                    G[p[i]][i] -= min;
                    G[i][p[i]] += min;
                    if (p[i] != 1 && i != e)//不记录虚拟出来的源点和汇点
                    {
                        int start = p[i] / 2;
                        int end = i / 2;
                        if (start != end)
                        {
                            insert(start, end, min);
                        }
                    }


                }
                sum += min;
                findend = true;
                break;
            }
            else//如果没有找到汇点
            {
                for (int i = 1; i <= e; i++)
                {
                    if (!visit[i] && G[temp][i] > 0)
                    {
                        q.push_back(i);
                        visit[i] = 1;
                        p[i] = temp;
                    }
                }
            }
        }
        if (!findend)
            break;
    }
    return sum;
}

int main()
{
    while (cin >> p >> m)
    {
        //p为部件的数目 m为机器的数目

        for (int i = 1; i <= m; i++)//输入m个机器的生产速度 input数据 和output数据
        {
            for (int j = 0; j < 2 * p + 1; j++)
            {
                cin >> input[i][j];
            }
        }
        e = 2 * m + 2;//由于添加了源点和汇点 总的点数加2

        constructGraph();
        int sum;
        sum = EdmondsKarp();
        if (sum)
        {
            cout << sum << " ";
            cout << a.size() << endl;
            output();
        }
        else
        {
            cout << 0 << " " << 0<<endl;
        }

    }

    return 0;
}