[codevs1022]覆盖

[codevs1022]覆盖

试题描述

有一个N×M的单位方格中，其中有些方格是水塘，其他方格是陆地。如果要用1×2的矩阵区覆盖（覆盖过程不容许有任何部分重叠）这个陆地，那么最多可以覆盖多少陆地面积。

输入

输入文件的第一行是两个整数N，M  (1<=N，M<=100)，第二行为一个整数K( K<=50)，接下来的K行，每行两个整数X，Y表示K个水塘的行列位置。(1<=X<=N，1<=Y<=M)。

输出

输出所覆盖的最大面积块（1×2面积算一块）。

输入示例

4 4
6
1 1
1 4
2 2
4 1
4 2
4 4

输出示例

4

数据规模及约定

见“输入”

题解

黑白染色后，挖去那几个被排除的点跑二分图匹配。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
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 20010
#define maxm 320010
#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 Q[maxn], hd, tl, vis[maxn];
	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));
		hd = tl = 0; Q[++tl] = s; vis[s] = 1;
		while(hd < tl) {
			int u = Q[++hd];
			for(int i = head[u]; i != -1; i = nxt[i]) {
				Edge& e = es[i];
				if(!vis[e.to] && e.flow) {
					vis[e.to] = vis[u] + 1;
					Q[++tl] = e.to;
				}
			}
		}
		return vis[t] > 1;
	}
	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 maxl 65
int n, m, K, CntP;
bool Map[maxl][maxl];
struct Node {
	int id;
	Node(): id(0) {}
	int p() { return id ? id : id = ++CntP; }
} nsi[maxl][maxl], nso[maxl][maxl], SS, TT;

int main() {
	n = read(); m = read(); K = read();
	rep(i, 1, K) {
		int x = read(), y = read();
		Map[x][y] = 1;
	}
	sol.init();
	rep(i, 1, n) rep(j, 1, m) if(!Map[i][j]){
		if(i < n && !Map[i+1][j]) sol.AddEdge(nso[i][j].p(), nsi[i+1][j].p(), 1), sol.AddEdge(nso[i+1][j].p(), nsi[i][j].p(), 1);
		if(j < n && !Map[i][j+1]) sol.AddEdge(nso[i][j].p(), nsi[i][j+1].p(), 1), sol.AddEdge(nso[i][j+1].p(), nsi[i][j].p(), 1);
		if((i ^ j) & 1) sol.AddEdge(SS.p(), nsi[i][j].p(), 1);
		else sol.AddEdge(nso[i][j].p(), TT.p(), 1);
		sol.AddEdge(nsi[i][j].p(), nso[i][j].p(), 1);
	}
	sol.setn(CntP);
	printf("%d
", sol.MaxFlow(SS.p(), TT.p()));
	
	return 0;
}