@description@
有一个n行m列的黑白棋盘，你每次可以交换两个相邻格子（相邻是指有公共边或公共顶点）中的棋子，最终达到目标状态。要求第i行第j列的格子只能参与mi,j次交换。
Input
第一行包含两个整数n，m（1<=n, m<=20）。以下n行为初始状态，每行为一个包含m个字符的01串，其中0表示黑色棋子，1表示白色棋子。以下n行为目标状态，格式同初始状态。以下n行每行为一个包含m个0~9数字的字符串，表示每个格子参与交换的次数上限。
Output
输出仅一行，为最小交换总次数。如果无解，输出-1。
Sample Input
3 3
110
000
001
000
110
100
222
222
222
Sample Output
4
@solution@
首先假如黑色棋子通过交换移动到了目标状态，那么白色棋子也就相应地变为了目标状态。
这意味着我们可以将黑色棋子视为 “有棋子”，白色棋子视为 “空格子”，将交换视为 “移动某个棋子到一个相邻的空格子”（因为不可能同色棋子之间交换）。
假如一个格子 p 起始情况是有棋子，终止情况也是有棋子，那么我们可以视作这个地方没有棋子。
为什么呢？假如 p 的棋子移动到了 x，而另一个 y 的棋子移动到了 p。它等价于没有 p 的棋子，y 直接移动到 x。
上面的思路其实还告诉我们，棋子与棋子之间是不会互相阻挡的（如果阻挡了就可以像上面一样等效替换掉）。
于是，起始情况有棋子而终止情况没有棋子的 p 需要移动到 终末情况有棋子而起始情况没有棋子的 q。
这非常像二分图匹配问题，可以使我们联想到网络流。
但是网络流建模中，没有很好的办法限制 “交换次数”。
假如一个格子起始情况与终末情况相同，那么其他棋子进这个格子的次数 = 出这个格子的次数。这个是比较显然的。
所以我们最多会有 (lfloor frac{m_{i, j}}{2}
floor) 个棋子经过这个格子，这样就可以把格子拆点，把边容量设为 (lfloor frac{m_{i, j}}{2}
floor)。
不同的情况，可以类似于上面推导出最多会有 (lceil frac{m_{i, j}}{2}
ceil)（包括一开始的棋子移出去和最后的棋子移进来） 个棋子经过这个格子。
于是建图就比较明显了：
对于初始状态与目标状态相同的 (i, j)，拆点 x -> x'，中间连容量为 (lfloor frac{m_{i, j}}{2}
floor) 的边。
对于初始状态有棋子，目标状态无棋子的 (i, j)，拆点 x -> x'，中间连容量为 (lceil frac{m_{i, j}}{2}
ceil) 的边；源点 s 向 x 连容量为 1 的边。
对于初始状态无棋子，目标状态有棋子的 (i, j)，拆点 x -> x'，中间连容量为 (lceil frac{m_{i, j}}{2}
ceil) 的边；x' 向汇点 t 连容量为 1 的边。
对于相邻的两个格子，之间连容量为 inf 的双向边。
跑最大流看是否满流。
@accepted code@
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 20;
const int INF = (1<<30);
const int MAXV = 2*MAXN*MAXN;
const int MAXE = 45*MAXV + 5;
const int dx[] = {0, 1, -1};
const int dy[] = {1, -1, 0};
struct FlowGraph{
struct edge{
int to, cap, flow, cost;
edge *nxt, *rev;
}edges[MAXE + 5], *adj[MAXV + 5], *cur[MAXV + 5], *ecnt;
FlowGraph() {ecnt = &edges[0];}
int s, t, cost;
void addedge(int u, int v, int c, int w) {
edge *p = (++ecnt), *q = (++ecnt);
p->to = v, p->cap = c, p->flow = 0, p->cost = w;
p->nxt = adj[u], adj[u] = p;
q->to = u, q->cap = 0, q->flow = 0, q->cost = -w;
q->nxt = adj[v], adj[v] = q;
p->rev = q, q->rev = p;
}
int f[MAXV + 5], hp[MAXV + 5];
void update(int x, int k) {
f[x] = k;
while( x ) {
hp[x] = x;
if( (x<<1) <= t && f[hp[x]] > f[hp[x<<1]] )
hp[x] = hp[x<<1];
if( (x<<1|1) <= t && f[hp[x]] > f[hp[x<<1|1]])
hp[x] = hp[x<<1|1];
x >>= 1;
}
}
int d[MAXV + 5], h[MAXV + 5];
bool relabel() {
for(int i=1;i<=t;i++)
h[i] += d[i], d[i] = f[i] = INF, hp[i] = i, cur[i] = adj[i];
d[s] = 0; update(s, 0);
while( f[hp[1]] != INF ) {
int x = hp[1]; update(x, INF);
for(edge *p=adj[x];p;p=p->nxt) {
int w = p->cost + h[x] - h[p->to];
if( d[x] + w < d[p->to] && p->cap > p->flow ) {
d[p->to] = d[x] + w;
update(p->to, d[p->to]);
}
}
}
return !(d[t] == INF);
}
bool vis[MAXV + 5];
int aug(int x, int tot) {
if( x == t ) return tot;
int sum = 0; vis[x] = true;
for(edge *&p=cur[x];p;p=p->nxt) {
int w = p->cost + h[x] - h[p->to];
if( d[x] + w == d[p->to] && p->cap > p->flow && !vis[p->to] ) {
int del = aug(p->to, min(tot - sum, p->cap - p->flow));
p->flow += del, p->rev->flow -= del, sum += del;
if( sum == tot ) break;
}
}
vis[x] = false;
return sum;
}
int min_cost_max_flow(int _s, int _t) {
s = _s, t = _t, cost = 0; int flow = 0;
while( relabel() ) {
int del = aug(s, INF);
flow += del, cost += del*(d[t] + h[t]);
}
return flow;
}
}G;
int n, m;
int A[MAXN + 5][MAXN + 5], B[MAXN + 5][MAXN + 5];
int C[MAXN + 5][MAXN + 5], id[MAXN + 5][MAXN + 5];
char str[MAXN + 5];
int main() {
scanf("%d%d", &n, &m);
for(int i=1;i<=n;i++) {
scanf("%s", str + 1);
for(int j=1;j<=m;j++)
A[i][j] = str[j] - '0';
}
for(int i=1;i<=n;i++) {
scanf("%s", str + 1);
for(int j=1;j<=m;j++)
B[i][j] = str[j] - '0';
}
for(int i=1;i<=n;i++) {
scanf("%s", str + 1);
for(int j=1;j<=m;j++)
C[i][j] = str[j] - '0';
}
int cnt = 0;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
id[i][j] = (++cnt);
int s = 2*cnt + 1, t = 2*cnt + 2, tot1 = 0, tot2 = 0;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) {
if( A[i][j] == B[i][j] )
G.addedge(id[i][j], id[i][j] + cnt, C[i][j] / 2, 0);
else if( A[i][j] == 1 && B[i][j] == 0 ) {
G.addedge(s, id[i][j], 1, 0); tot1++;
G.addedge(id[i][j], id[i][j] + cnt, (C[i][j] + 1) / 2, 0);
}
else if( A[i][j] == 0 && B[i][j] == 1 ) {
G.addedge(id[i][j] + cnt, t, 1, 0); tot2++;
G.addedge(id[i][j], id[i][j] + cnt, (C[i][j] + 1) / 2, 0);
}
for(int k=0;k<3;k++)
for(int l=0;l<3;l++) {
if( dx[k] == 0 && dy[l] == 0 ) continue;
int x = i + dx[k], y = j + dy[l];
if( 1 <= x && x <= n && 1 <= y && y <= m )
G.addedge(id[i][j] + cnt, id[x][y], INF, 1);
}
}
if( tot1 == tot2 && G.min_cost_max_flow(s, t) == tot1 )
printf("%d
", G.cost);
else puts("-1");
}
@details@
两个比较坑的点。
第一个是，它向周围的八连通连边，而不是通常我们常做的四连通。
第二个是，它起始状态与目标状态的棋子数量不一定保证相同。
其实本质上都是读题读仔细了都能解决的问题