[poj 1149]PIGS[网络流][Edmonds-Karp][Dinic]

【题目大意】

有M个猪圈，每个猪圈里初始时有若干头猪。一开始所有猪圈都是关闭的。依次来了N个顾客，每个顾客分别会打开指定的几个猪圈，从中买若干头猪。每个顾客分别都有他能够买的数量的上限。每个顾客走后，他打开的那些猪圈中的猪，都可以被任意地调换到其它开着的猪圈里，然后所有猪圈重新关上。问总共最多能卖出多少头猪。（1 <= N <= 100, 1 <= M <= 1000）

【建模方法】
不难想象，这个问题的网络模型可以很直观地构造出来。就拿上面的例子来说，可以构造出图1所示的模型（图中凡是没有标数字的边，容量都是∞）：
• 三个顾客，就有三轮交易，每一轮分别都有3个猪圈和1个顾客的结点。
• 从源点到第一轮的各个猪圈各有一条边，容量就是各个猪圈里的猪的初始数量。
• 从各个顾客到汇点各有一条边，容量就是各个顾客能买的数量上限。
• 在某一轮中，从该顾客打开的所有猪圈都有一条边连向该顾客，容量都是∞。
• 最后一轮除外，从每一轮的i号猪圈都有一条边连向下一轮的i号猪圈，容量都是∞，表示这一轮剩下的猪可以留到下一轮。
• 最后一轮除外，从每一轮被打开的所有猪圈，到下一轮的同样这些猪圈，两两之间都要连一条边，表示它们之间可以任意流通。

节点合并

规律1. 如果几个结点的流量的来源完全相同，则可以把它们合并成一个。
规律2. 如果几个结点的流量的去向完全相同，则可以把它们合并成一个。
规律3. 如果从点u到点v有一条容量为∞的边，并且点v除了点u以外没有别的流量来源，则可以把这两个结点合并成一个。

让我们从图4中重新总结一下构造这个网络模型的规则：
• 每个顾客分别用一个结点来表示。
• 对于每个猪圈的第一个顾客，从源点向他连一条边，容量就是该猪圈里的猪的初始数量。如果从源点到一名顾客有多条边，则可以把它们合并成一条，容量相加。
• 对于每个猪圈，假设有n个顾客打开过它，则对所有整数i∈[1, n)，从该猪圈的第i个顾客向第i + 1个顾客连一条边，容量为∞。
• 从各个顾客到汇点各有一条边，容量是各个顾客能买的数量上限。

<以上来自 [ 网络流建模汇总 ] [ Edelweiss ]    Orz >

相当于首顾客是中转站, 是他可开猪圈中猪数之和.

之后的顾客从首顾客中取出(若涉及首顾客所代表的猪圈)

若有新圏被打开, 则该顾客将成为新圏的中转站,

每个顾客向汇点连一条边, 边权为可买数, 表示此顾客作为中转站可以经手的猪数很多, 但带回家的数目是有限的.

前向星

[Edmonds-Karp]

//156K 0MS

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

const int INF = 0x3f3f3f3f;
const int MAXN = 105;
const int MAXM = 1005;
struct pool
{
    int v,pre,w;
}p[MAXN*MAXN*2];
int num,head[MAXN],pig[MAXM],flow[MAXN],pre[MAXN],M,N,S,T,opened[MAXM];
bool vis[MAXN];
queue<int> q;

void clear()
{
    num = 1;
    memset(head,0,sizeof(head));
    memset(opened,false,sizeof(opened));
}

void add(int u,int v,int w)
{
    p[++num].v = v, p[num].w = w, p[num].pre = head[u], head[u] = num;
}

int bfs()
{
    while(!q.empty())   q.pop();
    memset(flow,0,sizeof(flow));
    memset(vis,false,sizeof(vis));
    vis[S] = true;
    flow[S] = INF;
    q.push(S);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        for(int tmp=head[u],k;k=p[tmp].v,tmp;tmp=p[tmp].pre)
        {
            if(!vis[k]&&p[tmp].w>0)///选择可以流的管道进行更新
            {
                vis[k] = true;
                q.push(k);
                pre[k] = u;
                flow[k] = min(p[tmp].w,flow[u]);
            }
        }
    }
    return flow[T];
}

int Edmonds_Karp()
{
    int u,f,MaxFlow = 0;
    while((f=bfs()))
    {
        for(u=T;u>S;u=pre[u])
        {
            for(int tmp=head[pre[u]],k;k=p[tmp].v,tmp;tmp=p[tmp].pre)
            {
                if(k!=u) continue;
                p[tmp].w -= f;
                p[tmp^1].w += f;
                break;
            }
        }
        MaxFlow += f;
    }
    return MaxFlow;
}

int main()
{
    while(scanf("%d %d",&M,&N)==2)
    {
        S = 0;
        T = N+1;
        clear();
        for(int i=1;i<=M;i++)
            scanf("%d",pig+i);
        for(int i=1,a,u;i<=N;i++)
        {
            scanf("%d",&a);
            int MaxWeigh = 0;
            while(a--)
            {
                scanf("%d",&u);
                if(!opened[u])
                {
                    MaxWeigh += pig[u];
                    opened[u] = i;
                }
                else
                {
                    add(opened[u],i,INF);
                    add(i,opened[u],0);
                }
            }
            if(MaxWeigh)
                add(S,i,MaxWeigh), add(i,S,0);
            scanf("%d",&a);
            add(i,T,a);
            add(T,i,0);
        }
        printf("%d\n",Edmonds_Karp());
    }
}

[Dinic]

//140K 16MS

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;
int num, M, N, source, sink;
const int INF = 0x3f3f3f3f;
const int MAXN = 105;
const int MAXM = 1005;
int pig[MAXM],opened[MAXM];
/* The arc of the flow network.*/
struct Pool
{
    int next, t, c;
} edge[MAXM];
/* The point of the flow network.*/
struct Point
{
    int son, cur, pre, lim, d;
} a[MAXN];

int que[MAXN], fi, la;
bool vis[MAXN];

/* Build the hierarchical graph for the algorithm*/
bool build()
{
    memset(vis, 0, sizeof (vis));
    que[fi=la=0]=sink;//reverse
    a[sink].d=0, a[sink].cur=a[sink].son, vis[sink]=true;
    while (fi<=la)
    {
        int v=que[fi++];
        for (int now=a[v].son, u; u=edge[now].t, now; now=edge[now].next)
            if (edge[now^1].c&&!vis[u])//BFS来分层,这里和EK相同
            {//倒着BFS的话,当然引用的还是对侧边,即正向边
                a[u].d=a[v].d+1;//越向前标号渐大
                a[u].cur=a[u].son;//cur指向头
                vis[u]=true;//已遍历
                que[++la]=u;//入队
            }
        if (vis[source])return true;//层次图向前已经扩展到源点
    }
    return false;
}


/*Use the Dinic algorithm to calculate the max flow.*/
int MaxFlow()
{
    int u, v, now, ret=0;
    while (build())
    {
        a[u=source].lim=INF;
        while (true)
        {
            for (now=a[u].cur; v=edge[now].t, now; now=edge[now].next)//cur优化
                if (edge[now].c&&a[u].d==a[v].d+1)break;//找到了一个子节点属于层次图
            if (now)
            {
                a[u].cur=edge[now].next;//下一次从这一条边的下一条边开始dfs
                a[v].pre=now;//指向v的边的指针
                a[v].lim=min(a[u].lim, edge[now].c);///更新到此处为止流的上限
                if ((u=v)==sink)//如果已经找到了一条增广路(走到了尽头)
                ///注意这个地方借判断语句, 将u下移, 便于判断为否的时候回到上面进入下一层!
                {//进行增广
                    do
                    {
                        edge[a[u].pre].c-=a[sink].lim;
                        edge[a[u].pre^1].c+=a[sink].lim;//这两句和Edmonds-Karp是一样的,增广
                        u=edge[a[u].pre^1].t;//找前驱~!
                    } while (u!=source);
                    ret+=a[sink].lim;//增广完毕之后累加新找到的流
                }//否则(没走到尽头)继续向下DFS
            }
            else//没有子节点属于层次图
            {
                if (u==source)break;//已经退到了源,则已找到最大流,算法结束
                a[u].cur=now;//=0,此节点被废弃,子代亦然
                u=edge[a[u].pre^1].t;//根据反向边找到前驱~!
            }
        }
    }
    return ret;
}
void clear()
{
    num = 1;
    memset(a, 0, sizeof (a));
    memset(opened,false,sizeof(opened));
}

/* Add an arc to the flow network.*/
void add(int x, int y, int z)
{
    edge[++num].t=y;
    edge[num].c=z;
    edge[num].next=a[x].son;//相当于pool的head数组
    a[x].son=num;
}

int main()
{
    while(scanf("%d %d",&M,&N)==2)
    {
        source = 0;
        sink = N+1;
        clear();
        for(int i=1;i<=M;i++)
            scanf("%d",pig+i);
        for(int i=1,a,u;i<=N;i++)
        {
            scanf("%d",&a);
            int MaxWeigh = 0;
            while(a--)
            {
                scanf("%d",&u);
                if(!opened[u])
                {
                    MaxWeigh += pig[u];
                    opened[u] = i;
                }
                else
                {
                    add(opened[u],i,INF);
                    add(i,opened[u],0);
                }
            }
            if(MaxWeigh)
                add(source,i,MaxWeigh), add(i,source,0);
            scanf("%d",&a);
            add(i,sink,a);
            add(sink,i,0);
        }
        printf("%d\n",MaxFlow());
    }
}