[BZOJ1280][POJ1149]Emmy卖猪pigs

[BZOJ1280][POJ1149]Emmy卖猪pigs

试题描述

Emmy在一个养猪场工作。这个养猪场有 \(M\) 个锁着的猪圈，但Emmy并没有钥匙。顾客会到养猪场来买猪，一个接着一个。每一位顾客都会有一些猪圈的钥匙，他们会将这些猪圈打开并买走固定数目的猪。 所有顾客有的钥匙和他们需要买猪的数量在事先都告诉了Emmy，于是Emmy要订一个计划，使得卖出去的猪最多。 买卖的过程是这样的：一个顾客前来，并打开所有他可以打开的猪圈。然后Emmy从这些猪圈里牵出固定数目的猪卖给顾客（最多只能和顾客需要数相等），并可以重新安排这些开着的猪圈中的猪。 每个猪圈可以存放任意数目的猪。 写一个程序，使得Emmy能够卖出去尽可能多的猪。

输入

第一行有两个整数：\(M\) 和 \(N\)，表示猪圈数和顾客数。 第二行有 \(M\) 个整数，表示每个猪圈初始时有多少猪。 接下来的 \(N\) 行按照前来的次序描述了每一个顾客，每行的格式如下：\(A\ K_1\ K_2 \cdots K_A\ B\) \(A\) 表示该顾客拥有的钥匙数，\(K_1 \cdots K_A\) 表示每个钥匙所对应的猪圈，\(B\) 表示该顾客需要购买的猪的数目。

输出

仅包含一个整数，即最多能卖出去的猪的数目。

输入示例

3 3
3 1 10
2 1 2 2
2 1 3 3
1 2 6

输出示例

7

数据规模及约定

\(1 \le M \le 1000\)

\(1 \le N \le 100\)

题解

首先源点向每个猪圈连一条容量为该猪圈内猪数目的边，然后每位客户向汇点连一条容量为该客户需要数的边。这是显然的。

那么根据“可以打乱”这个性质，我们可以直接在客户和客户之间连边，而不是把边连回猪圈。

这样，正解就产生了（以下边容量均为无穷）：从猪圈向第一个有它钥匙的客户连边，然后有交集的客户之间连上边。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <vector>
using namespace std;
#define rep(i, s, t) for(int i = (s); i <= (t); i++)
#define dwn(i, s, t) for(int i = (s); i >= (t); i--)

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
	return x * f;
}

#define maxn 1111
#define maxm 24010
#define oo 2147483647

struct Edge {
	int from, to, flow;
	Edge() {}
	Edge(int _1, int _2, int _3): from(_1), to(_2), flow(_3) {}
};
struct Dinic {
	int n, m, s, t, head[maxn], nxt[maxm];
	Edge es[maxm];
	int vis[maxn], Q[maxn], hd, tl;
	int cur[maxn];
	
	void init() {
		m = 0; memset(head, -1, sizeof(head));
		return ;
	}
	void setn(int _) {
		n = _;
		return ;
	}
	
	void AddEdge(int a, int b, int c) {
		es[m] = Edge(a, b, c); nxt[m] = head[a]; head[a] = m++;
		es[m] = Edge(b, a, 0); nxt[m] = head[b]; head[b] = m++;
		return ;
	}
	
	bool BFS() {
		memset(vis, 0, sizeof(vis));
		vis[t] = 1;
		hd = tl = 0; Q[++tl] = t;
		while(hd < tl) {
			int u = Q[++hd];
			for(int i = head[u]; i != -1; i = nxt[i]) {
				Edge& e = es[i^1];
				if(!vis[e.from] && e.flow) {
					vis[e.from] = vis[u] + 1;
					Q[++tl] = e.from;
				}
			}
		}
		return vis[s] > 0;
	}
	
	int DFS(int u, int a) {
		if(u == t || !a) return a;
		int flow = 0, f;
		for(int& i = cur[u]; i != -1; i = nxt[i]) {
			Edge& e = es[i];
			if(vis[e.to] == vis[u] - 1 && (f = DFS(e.to, min(a, e.flow)))) {
				flow += f; a -= f;
				e.flow -= f; es[i^1].flow += f;
				if(!a) return flow;
			}
		}
		return flow;
	}
	
	int MaxFlow(int _s, int _t) {
		s = _s; t = _t;
		int flow = 0;
		while(BFS()) {
			rep(i, 1, n) cur[i] = head[i];
			flow += DFS(s, oo);
		}
		return flow;
	}
} sol;

#define maxpig 1010
#define maxcus 110
int n, p, A[maxpig];
vector <int> customer[maxpig];
bool G[maxcus][maxcus];

int main() {
	n = read(); p = read(); int S = n + p + 1, T = n + p + 2;
	sol.init(); sol.setn(T);
	rep(i, 1, n) sol.AddEdge(S, i, read());
	rep(i, 1, p) {
		int k = read();
		while(k--) customer[read()].push_back(i);
		sol.AddEdge(i + n, T, read());
	}
	
	rep(i, 1, n) if(customer[i].size()) {
		sol.AddEdge(i, customer[i][0] + n, oo);
		rep(j, 1, (int)customer[i].size() - 1) {
			int a = customer[i][j-1], b = customer[i][j];
			if(!G[a][b]) sol.AddEdge(a + n, b + n, oo), G[a][b] = 1;
		}
	}
	
	printf("%d\n", sol.MaxFlow(S, T));
	
	return 0;
}