奇怪的游戏 社论

SCOI2012 奇怪的游戏

一个 $n\times m$ 矩阵，初始 $(i,j)$ 有数 $a_{i,j}$，每次可以选两个相邻数同时加一，问至少操作几次使得所有数一样，无解输出 -1 .

$1\le n,m\le 40$，$\max\{a_i\}\le10^9$

骨牌题考虑黑白染色，设黑白点个数分别为 $c_{\sf B}, c_{\sf W}$，权值和分别为 $s_{\sf B}, s_{\sf W}$ .

每次操作肯定是恰好操作一个黑点和一个白点，于是设最后所有点都变成了 $x$，则有 $c_{\sf B}\cdot x-s_{\sf B}=c_{\sf W}\cdot x-s_{\sf W}$，也即 $(c_{\sf B}-c_{\sf W})x=s_{\sf B}-s_{\sf W}$ .

讨论：

1. 当 $c_{\sf B} - c_{\sf W} \neq 0$ 时 .
2. 当 $c_{\sf B} - c_{\sf W} = s_{\sf B} - s_{\sf W} = 0$ 时 .
3. 其他情况无解 .

---

Case 1. 可以解得 $x=\dfrac{s_{\sf B}-s_{\sf W}}{c_{\sf B} - c_{\sf W}}$ .

于是只要判断 $x$ 是否能作为一个解即可，具体见后 .

---

Case 2. 这表明黑白色块数量相等且权值和相等 .

因为黑白色块数量相等所以如果 $x$ 可以作为一个解那么 $x+1$ 必然也可以 .

也就是解有单调性，二分答案即可 . 判断 $x$ 是否能作为一个解的做法如下：

考虑建立虚拟源汇点 $s,t$：

• $s$ 向所有黑点 $(i,j)$ 连边权为 $x-a_{i,j}$ 的有向边 .
• 所有白点 $(i,j)$ 向 $t$ 连边权为 $x-a_{i,j}$ 的有向边 .
• 所有黑点 $(i,j)$ 向相邻白点连边权为 $+\infty$ 的有向边 .

因为 $x-a_{i,j}$ 是需要操作的次数，于是因为黑白色块数量权值和相等，如果有解那么流肯定能从 $s$ 流到黑点流到白点再流到 $t$ .

于是只要判断以 $s$ 为源点，$t$ 为汇点的最大流是否等于所有黑点之权值和即可 .

因为是二分图，所以 Dinic 是 $O(\sqrt nm)$ 的 .

---

这个还不足以作为时间复杂度分析，因为我们没有一个二分答案的上界 .

记 $\displaystyle A = \max_i\{a_i\}$，设二分图左部为 $L$，对应的 右部为 $R$ .

则根据最大流定义，有解当且仅当 $s$ 连向 $L$ 的容量和 $c_0$ 不小于 $R$ 连向 $t$ 的容量和 $c_1$ .

Hall 定理（7.16 闲话）告诉我们，对于任何一个 $L$，都有 $|L|\le |R|$ .

讨论：

• 当 $|L|=|R|$ 时，$c_0=c_1$ .

• 当 $|L|<|R|$ 时，当答案为 $0$ 时 $|c_0-c_1|\le A\cdot nm$ .

  注意到，若答案增加 $1$，$|c_0-c_1|$ 的 减少量 $\Delta\ge |T|-|S|\ge 1$ .

  于是答案的一个上界为 $A\cdot nm$ .

这样我们知道了答案的一个上界，就可以做复杂度分析了 .

时间复杂度为

$$\begin{aligned}T(n,m,A)&=O(\sqrt{nm}\cdot nm\cdot\log(A\cdot nm))\\&=O(n^{3/2}m^{3/2}(\log A+\log n+\log m))\\&=O(n^{3/2}m^{3/2}\log\max\{A,n,m\})\end{aligned}$$

注意到原题数据范围给出 $A$ 的量级远大于 $n,m$，于是时间复杂度为 $O(n^{3/2}m^{3/2}\log A)$ .

Code

#include <bits/stdc++.h>
template<typename T>
inline T chkmin(T& x, const T& y){if (x > y) x = y; return x;}
template<typename T>
inline T chkmax(T& x, const T& y){if (x < y) x = y; return x;}
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int TD = 44, N = 19198;
const ll INF = 0x3f3f3f3f3f;
struct dinic
{
	struct Node
	{
		int u, v; ll w;
		Node() = default;
		Node(int a, int b, ll c) : u(a), v(b), w(c){}
	};
	vector<Node> e;
	vector<int> g[N];
	inline void addedge(int u, int v, ll w)
	{
		int s = e.size();
		e.emplace_back(Node(u, v, w)); g[u].emplace_back(s++);
		e.emplace_back(Node(v, u, 0)); g[v].emplace_back(s);
	}
	int cur[N], depth[N];
	inline void clear(int n){e.clear(); do g[n].clear(); while (n--);}
	inline bool bfs(int s, int t)
	{
		memset(cur, 0, sizeof cur);
		memset(depth, -1, sizeof depth);
		queue<int> q; q.push(s); depth[s] = 0;
		while (!q.empty())
		{
			int u = q.front(); q.pop();
			for (int ee : g[u])
			{
				int v = e[ee].v;
				if (!~depth[v] && e[ee].w){depth[v] = depth[u] + 1; q.push(v);}
			}
		}
		return ~depth[t];
	}
	ll dfs(int u, int t, ll flow)
	{
		if ((u == t) || (flow <= 0)) return flow;
		ll ans = 0; int s = g[u].size();
		for (int& p = cur[u]; p < s; p++)
		{
			int ee = g[u][p], v = e[ee].v;
			if (depth[u] + 1 != depth[v]) continue;
			ll nxt = dfs(v, t, min(flow, e[ee].w));
			e[ee].w -= nxt; e[ee^1].w += nxt;
			ans += nxt; flow -= nxt;
			if (flow <= 0) break;
		}
		if (ans <= 0) depth[u] = -1;
		return ans;
	}
	inline ll maxflow(int s, int t)
	{
		ll ans = 0;
		while (bfs(s, t)) ans += dfs(s, t, INF);
		return ans;
	}
}F;
int n, m, a[TD][TD];
inline int color(int x, int y){return (x & 1) ^ (y & 1);}
inline int tonode(int x, int y){return x * 40 + y;}
inline bool check(ll x)
{
	int s = tonode(n, m) + 1, t = s + 1;
	F.clear(t);
	ll flow = 0;
	for (int i=1; i<=n; i++)
		for (int j=1; j<=m; j++)
		{
			if (color(i, j))
			{
				flow += x - a[i][j];
				F.addedge(s, tonode(i, j), x - a[i][j]);
				if (i > 1) F.addedge(tonode(i, j), tonode(i-1, j), INF); 
				if (j > 1) F.addedge(tonode(i, j), tonode(i, j-1), INF); 
				if (i < n) F.addedge(tonode(i, j), tonode(i+1, j), INF); 
				if (j < m) F.addedge(tonode(i, j), tonode(i, j+1), INF); 
			}
			else F.addedge(tonode(i, j), t, x - a[i][j]);
		}
	return F.maxflow(s, t) == flow;
}
inline void solve()
{
	scanf("%d%d", &n, &m);
	ll b = 0, w = 0; int B = 0, W = 0, M = 0;
	auto readInt = []()
	{
		int ans = 0; char ch;
		while (!isdigit(ch = getchar()));
		do ans = (ans<<3) + (ans<<1) + ch - 48; while (isdigit(ch = getchar()));
		return ans;
	};
	for (int i=1; i<=n; i++)
		for (int j=1; j<=m; j++)
		{
//			a[i][j] = readInt();
			scanf("%d", a[i] + j);
			chkmax(M, a[i][j]);
			if (color(i, j)){++B; b += a[i][j];}
			else{++W; w += a[i][j];}
		}
	if (B != W)
	{
		ll x = (b - w) / (B - W);
		if ((x >= M) && check(x)) printf("%lld\n", x * W - w);
		else puts("-1");
		return ;
	}
	if (b != w){puts("-1"); return ;}
	ll l = M, r = 3e9, ans = -1;
	while (l <= r)
	{
		ll mid = (l + r) >> 1;
		if (check(mid)){r = mid - 1; ans = mid;}
		else l = mid + 1;
	}
	if (!~ans) puts("-1");
	else printf("%lld\n", ans * W - w);
}
int main()
{
#ifndef ONLINE_JUDGE
	freopen("i.in", "r", stdin);
#endif 
	int T; scanf("%d", &T);
	while (T--) solve();
	return 0;
}