【最大流】【POJ1149】PIGS

【题目来源】 http://poj.org/problem?id=1149

 

【题目大意】  M个猪圈，每个猪圈里面有Mi头猪。有N个顾客要来买猪，每个人最大需求量Ni已知。每个顾客会指定打开哪几个猪圈，选择里面的猪购买。一开始猪圈都是关闭的，顾客打开之后，被打开的猪圈可以互相调换猪的数量，然后猪圈重新关闭。求最多卖出猪的数量。（1<=N<=100,1<=M<=1000）

【题目解析】 （最大流）设立汇点T，将所有顾客节点连到汇点T，容量为顾客的最大需求。 对于每个猪圈的第一个顾客，从源点S连有向边，容量为该猪圈猪的数量，如果有多条边连到同一个顾客，合并为一条，容量相加。然后是该猪圈的第i个顾客跟第i +１个顾客连有向边，容量为ＩＮＦ。

　　　　　　　建模分析 : 从顾客到汇点T的容量对应了顾客的最大需求量这一实际问题。“对于每个猪圈的第一个顾客，从源点S连有向边，容量为该猪圈猪的数量，如果有多条边连到同一个顾客，合并为一条，容量相加。”因此，从源点S到顾客的所有边上的总容量正好对应了所有猪圈猪的总数量。对于每个猪圈的第i个顾客和第i+1个顾客，表示第i个顾客选完之后可以轮到第i+1个顾客选择，另外一点，假设i打开了猪圈a和b，那么打开过猪圈a和b的人都会有边连到i上，因此i+1的来源就有a和b这2个猪圈，就能实现题目所说的“打开的猪圈可以互相调换猪的数量”这一条件。

【代码如下】

#include <iostream>
#include <cstdio>
#include <climits>
#include <cstring>
#include <vector>
#include <deque>
#include <algorithm>

//#define FILE_IO

using namespace std;

const int Maxn = 1002, INF = INT_MAX;

struct edge
{
    int v, c;
    edge* next, * op;
    edge(int _v, int _c, edge* _next) : v(_v), c(_c), next(_next) {}
}* E[Maxn], * Et[Maxn];

int S, T, Maxflow, N, M, Pigs[1001], Able[101], Buy[101];
vector <int> Lv, House[1001];
deque <int> Q;

void Init();
inline void edgeAdd(int, int, int);
void Dinic();
bool Dinic_Label();
int Dinic_Augment(int, int);
void Print();


int main()
{
    #ifdef FILE_IO
    freopen("1149.in", "r", stdin);
    #endif

    Init();
    Dinic();
    Print();

    return 0;
}

void Init()
{
    cin >> M >> N;
    S = 0; T = N + 1;
    for (int i = 1; i <= M; i ++) cin >> Pigs[i];
    for (int i = 1; i <= N; i ++)
    {
        int n; cin >> n;
        for (int j = 1; j <= n; j ++)
        {
            int y; cin >> y;
            if (House[y].empty())
            {
                House[y].push_back(i);
                Able[i] += Pigs[y];
            }
            else
            {
                edgeAdd(House[y].back(), i, INF);
                House[y].push_back(i);
            }
        }
        cin >> Buy[i];
    }
    for (int i = 1; i <= N; i ++)
        if (Able[i]) edgeAdd(S, i, Able[i]);
    for (int i = 1; i <= N; i ++) edgeAdd(i, T, Buy[i]);
}

inline void edgeAdd(int x, int y, int c)
{
    E[x] = new edge(y, c, E[x]);
    E[y] = new edge(x, 0, E[y]);
    E[x] -> op = E[y]; E[y] -> op = E[x];
}

void Dinic()
{
    while (Dinic_Label())
    {
        memcpy(Et, E, sizeof(Et));
        Maxflow += Dinic_Augment(S, INF);
    }
}

bool Dinic_Label()
{
    Lv.assign(T + 1, -1); Lv[S] = 0;
    Q.clear(); Q.push_back(S);
    while (!Q.empty())
    {
        int i = Q.front(); Q.pop_front();
        for (edge* j = E[i]; j; j = j -> next)
        {
            if (j -> c && Lv[j -> v] == -1)
            {
                Lv[j -> v] = Lv[i] + 1;
                if (j -> v == T) return true;
                Q.push_back(j -> v);
            }
        }
    }
    return false;
}

int Dinic_Augment(int i, int bm)
{
    if (i == T || bm == 0) return bm;
    int iflow = 0;
    for (edge* &j = Et[i]; j; j = j -> next)
    {
        if (j -> c && Lv[i] + 1 == Lv[j -> v])
        {
            int add = Dinic_Augment(j -> v, min(bm, j -> c));
            j -> c -= add;
            j -> op -> c += add;
            iflow += add;
            bm -= add;
            if (bm == 0) break;
        }
    }
    return iflow;
}

void Print()
{
    cout << Maxflow << endl;
}