Dining POJ - 3281 （拆点网络流）

题目连接

题意：

N 头牛， F 种食物 （食物只有一份）， D 种饮料（饮料只有一份）

然后每头牛喜欢哪些食物，哪些饮料。每头牛只有喝了自己喜欢喝的饮料，吃了自己喜欢吃的食物才会开心

问最多能让多少头牛开心。

思路：

1）最大流模板，（添加 源点 和 汇点）

2）但是存在问题，每个牛可能会吃多种食物，喝多种饮料，怎么能这种情况怎么能出现呢？（影响牛牛社会不平衡）

3）那就限制每头牛只能吃一个，怎么限制呢？

4）加条流量为 1 边，把每头奶牛这个点给拆成两个点，将同一头牛的两点连线（流量限制为 1 ），这样，就能保证每头牛不会多吃，多喝了。

AC代码:

#include<iostream>
#include<cstring>
#include<math.h>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 700;
const int maxm = 1e5;
const int inf = 0x3f3f3f3f;
int N, F, D;
int s, e;

struct ac{
    int v, c, nex;
}edge[maxm];

int head[maxn], dis[maxn], curedge[maxn], cnt;
void init() {
    cnt = 0;
    memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int c) {
	// 正向建边
    edge[cnt] = {v, c, head[u]};
    head[u] = cnt++;
    // 反向建边, 流量为0
    edge[cnt] = {u, 0, head[v]};
    head[v] = cnt++;
}
bool bfs() {
    queue<int> que;
    que.push(s);
    memset(dis, 0, sizeof(dis)); // 对图进行分层
    dis[s] = 1;
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        for (int i = head[u]; i != -1; i = edge[i].nex) {
        	int v = edge[i].v;
        	int c = edge[i].c;
        	// 如果节点v已经分过层或者u->v流量为0, continue
            if (dis[v] || c == 0) continue;
            dis[v] = dis[u] + 1; // 对v进行标记并加入队列
            que.push(v);
        }
    }
    return dis[e] > 0;  // 判断是否存在增广路，s是否能到达e
}

int dfs(int u, int flow) { // 增广路走到u点的最小流量为flow
    if (u == e || flow == 0) return flow;
    // 遍历u的所有出边
    for (int &i = curedge[u]; i != -1; i = edge[i].nex) { // 当前弧优化
    	int v = edge[i].v;
    	int c = edge[i].c;
    	// 判断能否u->v增广
        if (dis[v] != dis[u] + 1 || c == 0) continue;
        int d = dfs(v, min(flow, c));
        if (d > 0) { // 找到一条增广路，修改增广路上的正反向边
            edge[i].c -= d;
            edge[i^1].c += d;
            return d;
        }            
    }
    dis[u] = -1; // // 炸点优化
    return 0;
}
int Dinic() {
    int sum = 0, d;
    while (bfs()) { // 判读是否存在增广路
        for (int i = 0; i <= e; ++i) curedge[i] = head[i]; // copy head数组，在dfs中可以直接得到下一条没有被增广过的边
        while ((d = dfs(s, inf)) > 0) sum += d; // 多次dfs找增广路
	}
    return sum;
}
int main(){
	while ( cin >> N >> F >> D) {
		int Fi, Di;
		init();
		s = 0;
		e = 600;
		int food, drink;
		for(int j = 1; j <= F; j++){
			addedge(s, j, 1);
		}
		for(int j = 1; j <= D; j++){
			addedge( j + 300, e, 1);
		}
		for (int i = 1; i <= N; ++i) {
			cin >> Fi >> Di;
			for (int j = 1; j <= Fi; ++j){
				cin >> food;
				addedge( food, i + 100, 1);
			} 
			addedge( i + 100, i + 200, 1);
			for (int j = 1; j <= Di; ++j) {
				cin >> drink;
				addedge( i + 200 , drink + 300, 1);
			}
		}
		cout << Dinic() << endl;
	}
	return 0;
} 

第一次遇到拆点题，小结下

当对某个东西有限制时（比如对牛，只让他喝一种饮料，吃一种食物），那如果一头牛能吃2个食物，2个饮料呢？

这就需要对中途经过的重要点 进行拆点。

 

又感觉自己学会了？？？

抛出个问题。

如果一头牛需要吃2个食物，喝1个饮料才会开心，那怎么解决呢？