最大流（二）

---

poj上几题最大流的题。

poj1273 Drainage Ditches

说明：

裸题

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <vector>

using namespace std;

#define INF 99999999

const int max_v=234;

struct Edge{
    int to,cap,rev;
};

vector<Edge>G[max_v];
int level[max_v];
int iter[max_v];

void add_edge(int from,int to,int cap){
    G[from].push_back((Edge){to,cap,(int)G[to].size()});
    G[to].push_back((Edge){from,0,(int)G[from].size()-1});
}

void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();
        que.pop();
        for(int i=0;i<G[v].size();i++){
            Edge &e=G[v][i];
            if(e.cap>0 && level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v,int t,int f){
    if(v==t)return f;
    for(int &i=iter[v];i<G[v].size();i++){
        Edge &e=G[v][i];
        if(e.cap>0 && level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t){
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0){
            flow+=f;
        }
    }
}

int n,m,s,t;
int a,b,c;

int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        s=1;
        t=m;
        for(int i=0;i<=m;i++)G[i].clear();
        for(int i=0;i<n;i++){
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
        }
        printf("%d\n",max_flow(s,t));
    }
    return 0;
}

poj3281 Dining

题意：

农夫有 F 种食物和 D 种饮料，他要把食物和饮料分给 N 头牛，每头牛都有喜欢的食物和饮料，每种食物和每种饮料都只能给一头牛，问最多有多少头牛能同时得到喜欢的事物和饮料。

说明：

把每头牛拆成两个点：in 和 out 。不能对食物或饮料拆点，刚开始的时候我就对食物拆点，然后一直 wa 。后来看了discuss里的解释才想明白：如果拆食物，按照 牛->食物in->食物out->饮料 这样建图的话，虽然保证了流量的限制，每头牛也只能选一种食物和饮料。但是 食物out->饮料 之间的边就失去的牛的编号性，就成了没有针对哪头牛的组合，不知道某些边是哪些牛的喜好。这样就会导致某头牛明明不喜欢某种搭配，但是因为有其他牛喜欢这种搭配，使得这头牛“强行”被选择了这种搭配。所以就会 wa 。

建图：

源点到每种食物连一条边，容量为1；每头牛所喜欢的食物到那头牛 in 连一条边，容量为1；每头牛 in 到牛 out 连一条边，容量为1；每头牛 out 到它所喜欢的所有饮料各连一条边，容量为1；每种饮料到汇点连一条边，容量为1。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <vector>

using namespace std;

#define INF 99999999

const int max_v=456;

struct Edge{
    int to,cap,rev;
    Edge(int to,int cap,int rev){
        this->to=to;
        this->cap=cap;
        this->rev=rev;
    }
};

vector<Edge>G[max_v];
int level[max_v];
int iter[max_v];

void add_edge(int from,int to,int cap){
    G[from].push_back(Edge(to,cap,(int)G[to].size()));
    G[to].push_back(Edge(from,0,(int)G[from].size()-1));
}

void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();
        que.pop();
        for(int i=0;i<G[v].size();i++){
            Edge &e=G[v][i];
            if(e.cap>0 && level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v,int t,int f){
    if(v==t)return f;
    for(int &i=iter[v];i<G[v].size();i++){
        Edge &e=G[v][i];
        if(e.cap>0 && level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t){
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0){
            flow+=f;
        }
    }
}

int n,f,d,fi,di,temp;

int main(){
    scanf("%d%d%d",&n,&f,&d);
    int s=0;
    int t=n+n+f+d+1;
    for(int i=1;i<=f;i++){
        add_edge(s,i,1);
    }
    for(int i=1;i<=n;i++){
        scanf("%d%d",&fi,&di);
        for(int j=0;j<fi;j++){
            scanf("%d",&temp);
            add_edge(temp,i+f,1);
        }
        add_edge(i+f,i+f+n,1);
        for(int j=0;j<di;j++){
            scanf("%d",&temp);
            add_edge(i+f+n,temp+f+2*n,1);
        }
    }
    for(int i=1;i<=d;i++){
        add_edge(i+f+2*n,t,1);
    }
    printf("%d\n",max_flow(s,t));
    return 0;
}

---

poj 1149 PIGS

题意：

有 m 个猪圈和 n 个顾客，每个猪圈都有若干头猪，每个顾客想买若干头猪，每个顾客有某几个猪圈的钥匙，顾客只能买那几个猪圈里的猪；每次猪圈同时开启时，可以将猪圈里的猪换到别的猪圈。问最多能卖出多少头猪。

说明：

构图很神奇，刚学最大流的时候，做的第一题是水题，第二题就是这题，当时真是难哭我。

建图：

源点到每个猪圈连一条边，容量为初始猪圈内猪的数量；每个猪圈到拥有该猪圈钥匙的所有人各连一条边，容量为INF ；对于每个猪圈，拥有该猪圈钥匙的前一个人到后一个人连一条边，容量为INF ；每个人到汇点连一条边，容量为其想购买的猪的个数。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;

#define INF 9999999

const int max_v=1234;

int pig[1001];

struct Edge{
    int to,cap,rev;
};

vector<Edge>G[max_v];
bool used[max_v];

void add_edge(int from,int to,int cap){
    G[from].push_back((Edge){to,cap,(int)G[to].size()});
    G[to].push_back((Edge){from,0,(int)G[from].size()-1});
}

int dfs(int v,int t,int f){
    if(v==t)return f;
    used[v]=1;
    for(int i=0;i<G[v].size();i++){
        Edge &e=G[v][i];
        if(!used[e.to] && e.cap>0){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t){
    int flow=0;
    for(;;){
        memset(used,0,sizeof(used));
        int f=dfs(s,t,INF);
        if(f==0)return flow;
        flow+=f;
    }
}

int main(){
    int n,m;
    int a,b,c,d;
    while(scanf("%d%d",&m,&n)!=EOF){
        memset(pig,-1,sizeof(pig));
        for(int i=0;i<m+n+7;i++){
            G[i].clear();
        }
        for(int i=1;i<=m;i++){
            scanf("%d",&a);
            add_edge(0,i,a);
        }
        for(int i=1;i<=n;i++){
            scanf("%d",&b);
            for(int j=0;j<b;j++){
                scanf("%d",&c);
                if(pig[c]!=-1){
                    add_edge(pig[c],i+m,INF);
                }
                pig[c]=i+m;
                add_edge(c,i+m,INF);
            }
            scanf("%d",&d);
            add_edge(i+m,m+n+1,d);
        }

        printf("%d\n",max_flow(0,m+n+1));
    }
    return 0;
}

---