[BZOJ1059][ZJOI2007]矩阵游戏

[BZOJ1059][ZJOI2007]矩阵游戏

试题描述

小Q是一个非常聪明的孩子，除了国际象棋，他还很喜欢玩一个电脑益智游戏——矩阵游戏。矩阵游戏在一个N*N黑白方阵进行（如同国际象棋一般，只是颜色是随意的）。每次可以对该矩阵进行两种操作：行交换操作：选择矩阵的任意两行，交换这两行（即交换对应格子的颜色）列交换操作：选择矩阵的任意行列，交换这两列（即交换对应格子的颜色）游戏的目标，即通过若干次操作，使得方阵的主对角线(左上角到右下角的连线)上的格子均为黑色。对于某些关卡，小Q百思不得其解，以致他开始怀疑这些关卡是不是根本就是无解的！！于是小Q决定写一个程序来判断这些关卡是否有解。

输入

第一行包含一个整数T，表示数据的组数。接下来包含T组数据，每组数据第一行为一个整数N，表示方阵的大小；接下来N行为一个N*N的01矩阵（0表示白色，1表示黑色）。

输出

输出文件应包含T行。对于每一组数据，如果该关卡有解，输出一行Yes；否则输出一行No。

输入示例

2
2
0 0
0 1
3
0 0 1
0 1 0
1 0 0

输出示例

No
Yes

数据规模及约定

对于100%的数据，N ≤ 200

题解

注意到任何一次交换操作都不会改变任何一行或一列中 1 的个数，就是说我们给矩阵的行和列进行编号，交换位置后编号不变，那么编号为 i 的行（列）中的任何一个元素不会跑到编号为 j(j ≠ i) 的行（列）中去。

好，我们给每行、每列编好号之后，假设最终有解，我们设最终这个主对角线上都是 1 的矩阵的行编号变成了 p₁, p₂, p₃, ... , p_n，列编号变成了 q₁, q₂, q₃, ... , q_n，其中 p 和 q 都是一个 1~n 的排列（如下图）。

那么在原矩阵中只要满足 A[p₁][q₁] = A[p₂][q₂] = A[p₃][q₃] = ... = A[p_n][q_n]  就好了，换句话说，就是我们要对于每一个行的编号找到一个只属于它的唯一的列编号，听起来像二分图匹配？那就开写吧！

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;

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 410
#define maxm 80810
#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(int n) {
		this->n = n;
		m = 0; memset(head, -1, sizeof(head));
		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(e.flow && !vis[e.to]) {
					vis[e.to] = vis[u] + 1;
					Q[++tl] = e.to;
				}
			}
		}
		return vis[t] > 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) {
		this->s = s; this->t = t;
		int flow = 0;
		while(BFS()) {
			for(int i = 1; i <= n; i++) cur[i] = head[i];
			flow += DFS(s, oo);
		}
		return flow;
	}
} sol;

int main() {
	int T = read();
	while(T--) {
		int n = read();
		sol.init((n << 1) + 2); int s = n << 1 | 1, t = s + 1;
		for(int i = 1; i <= n; i++) {
			sol.AddEdge(s, i, 1);
			sol.AddEdge(i + n, t, 1);
			for(int j = 1; j <= n; j++) {
				int x = read();
				if(x) sol.AddEdge(i, j + n, 1);
			}
		}
		if(sol.MaxFlow(s, t) == n) puts("Yes"); else puts("No");
	}
	
	return 0;
}