[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());    }}