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 = 0xfffff;
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++)
    {
        if (i < a.size() - 1)
            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;
            }

        }
}
bool bfs()
{
    deque<int> q;
    q.push_back(1);
    memset(layer, -1, sizeof(layer));//把所有没有访问过的点的层数设置为-1 作为没有访问的标识
    layer[1] = 0;
    while (!q.empty())
    {
        int temp = q.front();
        q.pop_front();
        for (int i = 1; i <= e; i++)
        {
            if (layer[i] == -1 && G[temp][i] > 0)//i没有被访问过且 temp到I有路径
            {
                layer[i] = layer[temp] + 1;
                q.push_back(i);
                if (i == e)//bfs从第源点找到了汇点
                    return true;
            }
        }
    }
    return false;//从源点的bfs没有找到汇点
}
int dinic()
{
    int sum = 0;//存储最大流量
    deque<int> q;
    while (bfs())
    {
        memset(visit, 0, sizeof(visit));//清空visit数组
        q.push_back(1);
        visit[1] = 1;
        while (!q.empty())
        {
            int temp = q.back();
            if (temp == e)//找到了汇点
            {
                int min = INF;//增广路径中的增量
                int mins;//增量的起点
                for (int i = 1; i < q.size(); i++)//寻找增量
                {
                    int u = q[i - 1];
                    int v = q[i];
                    if (G[u][v] < min)
                    {
                        min = G[u][v];
                        mins = u;
                    }
                }
                sum += min;//增加总的流量
                for (int i = 1; i < q.size(); i++)//更新网络
                {
                    int u = q[i - 1];
                    int v = q[i];
                    G[u][v] -= min;
                    G[v][u] += min;
                    int start, end;
                    if (u != 1&& v != e)//插入增广路径中的起点和终点（除了后来添加的源点和汇点）
                    {
                        start = u / 2;
                        end = v / 2;
                        if (start != end)//如果不是机器内部的流量 而是不同的机器相连接
                        {
                            insert(start,end, min);
                        }
                    }
                }
                for (int a = q.back(); (!q.empty()) && (a != mins); q.pop_back())//回溯到增量的起点 寻找下条增广路径
                    visit[a] = 0;
            }
            else//没有找到汇点
            {
                int i;
                for (i = 1; i <= e; i++)
                {
                    if (!visit[i] && G[temp][i]>0 && layer[i] == layer[temp] + 1)
                    {
                        q.push_back(i);
                        visit[i] = 1;
                        break;
                    }
                }
                if (i > e)//根据当前的dfs没有找到汇点 且访问完了所有节点 则回溯
                    q.pop_back();
            }
        }
    }
    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 = dinic();
        if (sum)
        {
            cout << sum << " ";
            cout << a.size() << endl;
            output();
        }
        else
        {
            cout << 0 << " " << 0<<endl;
        }

    }

    return 0;
}