网络流 口胡

我是口胡大王

允许负流量有上下界的源-汇最大流（已实现）

• 连 $T\to S$ 上界 $\inf$，下界 $-\inf$ 的边
• 无源汇可行流 $\to$ 有源汇最大流，注意到此时已经没有负容量了；找到此时 $T\to S$ 边的流量
• 删 $s,t$ 点、$T\to S$ 的 $\inf$ 边，再跑最大流

无负环的最小费用源-汇最大流（已实现）

• 直接 Simplex

有上下界、负权环和源汇的最小费用可行流、最大流和最小流（已实现）

• 先连 $T\to S$ 上界 $\inf$，下界 $-\inf$，费用 $0$ 的边
• 无源汇可行流 $\to$ 有源汇最大流，判断是否可行，找到此时 $T\to S$ 边的流量
• 把这张图复制三遍，跑三遍 Simplex

全非负权的最小权稀疏二分图匹配（已实现）

• 费用流，秒了！

最小权稠密二分图匹配（已实现）

• 费用流，秒了！

最大最小欧拉回路（已实现）

• 二分答案，问题变成：给无向边定向，问能不能构成欧拉回路
• 有向图为欧拉图的充要条件：每个点出度等于度数的一半
• 若边 $(u,v)$ 有向，他给 $u$ 提供 1 的出度，若无向，给 $u$ 或 $v$ 提供 1 的出度
• 边 $i$ 建点 $e_i$，点 $u$ 建点 $p_u$，$s\to e_i$ 容量为 $1$，$p_i\to t$ 容量为 $\frac{\text{deg}(i)}2$，若 $i$ 边 $(u,v)$ 有向，则 $e_i$ 向 $p_u$ 连容量为 $1$ 的边，否则向 $p_u,p_v$ 连容量为 $1$ 的边
• 跑最大流，看是否满流、再看哪些 $e_i\to p_j$ 流过了即可定向，最后 DFS 输出方案即可。

= P3511

环形铁路

数学做法

• 总货物数一定，故每个库最后拥有的货物数一定，故每个库要转出或转入的货物数一定
• 因为每个库只能和两个库交易，故确定和一个库的交易后即可确定与另一个库的交易
• 推广发现，若确定其中一组相邻的交易，就能确定其余所有交易，答案就是个一元函数
• 设 $1\to n$ 交易了 $x$，每个库所需转出量为 $a_i$，则 $2\to 1$ 交易 $x-a_1$，$3\to 2$ 交易 $(x-a_1)-a_2$，$4\to 3$ 交易 $((x-a_1)-a_2)-a_3$……
• 设 $b_i$ 为 $a_i$ 前缀和，$Ans=\min_x\{|x-b_0|+|x-b_1|+\ldots+|x-b_{n-1}|\}$，搞出中位数代入计算即可
• $O(n)$

费用流做法

• 设货物数量序列为 $a$，$m=\overline{a}$，下标从 $0$ 开始，$c$ 为容量、$p$ 为费用
• 建点 $s,t$，每个仓库 $i$ 建点 $p_i$
• $\forall i\in[1..n]$，$p_i\to p_{(i-1)\bmod n}$，$p_i\to p_{(i+1)\bmod n}$，$c=+\infty$，$p=1$
• $\forall i\in[1..n]\land a_i>m$，$s\to p_i$，$c=a_i-m$，$p=0$
• $\forall i\in[1..n]\land a_i<m$，$p_i\to t$，$c=m-a_i$，$p=0$
• 跑最小费用最大流，最小费用即为答案

= P4016

卖猪

• 建点 $s,t$，每个客人 $i$ 建点 $q_i$
• $\forall i\in[1..n],v\in K_i$：
  • 若 $i$ 是 $v$ 的第一个客人，$s\to q_i$，$c=p_v$
  • 否则，设上一个客人为 $j$，$q_j\to q_i$，$c=+\infty$
• $\forall i\in[1..n]$，$q_i\to t$，$c=b_i$
• 跑最大流，最大总流量即为答案

= POJ 1149

志愿者招募

• 设 $l$ 为流量下界，$u$ 为流量上界，$p$ 为费用
• 第 $i$ 天建点 $F_i,G_i$
• $\forall i\in[1..n]$，$F_i\to G_i$，$l=A_i$，$u=+\infty$，$p=0$
• $\forall i\in[1..n-1]$，$G_i\to F_{i+1}$，$l=0$，$u=+\infty$，$p=0$
• $\forall j\in[1..m]$，$G_{T_j}\to F_{S_j}$，$l=0$，$u=+\infty$，$p=C_j$
• 跑最小费用可行流，最小费用即为答案

= P3980

餐巾问题

• 设 $l$ 为流量下界，$u$ 为流量上界，$p$ 为费用
• 建点 $s,t$，第 $i$ 天建点 $F_i,G_i$
• $\forall i\in[1..n]$：
  • $F_i\to G_i$，$l=r_i$，$u=+\infty$，$p=0$
  • $s\to F_i$，$l=0$，$u=+\infty$，$p=p_1$
  • $G_i\to t$，$l=0$，$u=+\infty$，$p=0$
• $\forall i\in[1..n-1]$，$F_i\to F_{i+1}$，$l=0$，$r=+\infty$，$p=0$
• $\forall i\in[1..n-t_2]$，$G_i\to F_{i+t_2}$，$l=0$，$r=+\infty$，$p=p_2$
• $\forall i\in[1..n-t_3]$，$G_i\to F_{i+t_3}$，$l=0$，$r=+\infty$，$p=p_3$
• 跑最小费用可行流，最小费用即为答案

= P1251

星际转移问题

• 设 $p_i$ 为 $i$ 船的停靠站周期序列（$p_i$ 内下标从 0 开始），$k_i=|p_i|$，$c$ 为容量
• 无解条件：
  • $\forall i\in[1..m],j\in[0..k_i-2]$，并查集中合并 $p_{i,j},p_{i,j+1}$ 连通块
  • 若 $0,-1$ 不连通，则无解
• 从小到大枚举答案 $x$，每次在上一张图的残量网络上继续加边继续跑
• 建点 $s,t$，对于每个站点 $i\in[-1..n]$、每个时间 $t\in[0..x]$，建点 $q(i,t)$
• $x=0$ 时：
  • $s\to q(0,0)$，$c=k$
  • $q(-1,0)\to t$，$c=+\infty$
• 否则，新加边：
  • $\forall j\in[1..m]$，$q(p_{j,(x-1)\bmod k_j},x-1)\to q(p_{j,x\bmod k_j},x)$，$c=h_j$
  • $\forall i\in[0..n]$，$q(i,x-1)\to q(i,x)$，$c=+\infty$
  • $q(-1,x)\to q(-1,x-1)$，$c=+\infty$
• 若满流则 $x$ 满足条件，退出
• 答案上界：
  • 研究一条可行的流，他的流量至少为 $1$
  • 首先他不会重复经过一个点，因为你总可以将其替换成一直在该点停留
  • 其次在一个点停留的时间至多为 $n+2$，因为假如存在一个经过该点的船，他最多隔 $n+2$ 的时间就会访问到该点
  • 故答案上界为 $k\cdot(n+2)^2=11250$
• 因为答案 $\le11250$，故点数、边数不会爆炸
• 该方法比直接二分快

= P2754

管道清洁

• 设 $l$ 为流量下界，$r$ 为流量上界，$p$ 为费用
• 建边：
  • 对于一号边 $(u,v)$，建边 $u\to v$，$l=1$，$r=1$，$p=1$
  • 对于二号边 $(u,v)$，建边 $u\to v$，$l=1$，$r=+\infty$，$p=1$
  • 对于三号边 $(u,v)$，建边 $u\to v$，$l=0$，$r=1$，$p=1$
  • 对于四号边 $(u,v)$，建边 $u\to v$，$l=0$，$r=+\infty$，$p=1$
• 把 $1$ 号点拆为 $s,t$，$1$ 的所有出边由 $s$ 连出、所有入边由 $t$ 连入
• 跑源-汇最小费用可行流，可以判有/无解，若有解则最小费用为答案

宝石问题

• 设机器人起点集合为 $B$、终点集合为 $E$，$c$ 为容量，$p$ 为费用
• 建点 $s,t$，每个格子 $(i,j)$ 拆为两个点 $p_1(i,j),p_2(i,j)$
• $\forall i\in[1..r],j\in[1..c]$：
  • $p_1(i,j)\to p_2(i,j)$，$c=1$，$p=-v_{i,j}$
  • $p_1(i,j)\to p_2(i,j)$，$c=+\infty$，$p=0$
• $\forall i\in[1..r],j\in[1..c-1]$，$p_2(i,j)\to p_1(i,j+1)$，$c=+\infty$，$p=0$
• $\forall i\in[1..r-1],j\in[1..c]$，$p_2(i,j)\to p_1(i+1,j)$，$c=+\infty$，$p=0$
• $\forall(i,j)\in B$，$s\to p_1(i,j)$，$c=1$，$p=0$
• $\forall(i,j)\in E$，$p_2(i,j)\to t$，$c=1$，$p=0$
• 跑源-汇最小费用最大流，最小费用的相反数即为答案

双向路径问题

暴力

• 设 $c$ 为容量，$p$ 为费用
• 建点 $S,T$，原图每个点 $u$ 拆为 $p_u,q_u$
• $\forall u\in[1..n]$，$p_u\to q_u$，$c=1$，$p=1$
• $S\to q_s$，$c=2$，$p=0$
• $p_t\to T$，$c=2$，$p=0$
• 对于原图边 $(u,v)$，建边 $q_u\to p_v$，$c=+\infty$，$p=0$
• 跑最大费用最大流，若满流则有解，答案为最大费用
• $O(nm)$，不能通过

优化 1

• 用单纯形网络流碾过去
• 理论复杂度为指数级

优化 2

• 考虑原始对偶的过程，发现第一次 SPFA 可以替换成 DAG 上的 DP
• $O(m\log n)$

同余最大流

• 设 $f$ 为流量，$L$ 为流量下界，$U$ 为流量上界
• 首先，$\forall e\in E,r(e)\gets r(e)\bmod Q$
• 原题相当于，你要对每条边 $(u,v,L,U,r)$ 定一个 $k$，令其流量为 $r+k\cdot Q$，需要满足：
  • 流量平衡条件
  • 流量上下界条件
  • 有解情况下，最大化 $\sum_{(s,v,f)}f$
• 首先，若 $\exists u\in[1..n],\sum_{(v,u,L,U,r)\in E}r\not\equiv\sum_{(u,v,L,U,r)\in E}r\pmod{Q}$，则无解
• 令 $c_u=\dfrac{\sum_{(v,u,L,U,r)\in E}r-\sum_{(u,v,L,U,r)\in E}r}Q$
• 考虑建出新图，新图中每条边的流量对应原图中该边的 $k$
• 建点 $S,T$，对于原图中每个点 $u$ 建点 $d_u$
• 对原图每条边 $(u,v,L,U,r)$ 算出满足 $r+k\cdot Q\in[L..U]$ 的 $k$ 的取值范围 $[p..q]$，若不存在 $k$ 使条件满足，则无解；否则在新图中建边 $d_u\to d_v$，$L=p$，$U=q$
• 对于每个点 $u\in[1..n]$，若 $c_u>0$，建边 $S\to d_u$，$L=0$，$U=c_u$；若 $c_u<0$，建边 $d_u\to T$，$L=0$，$U=-c_u$
• 先以 $S$ 为源点、$T$ 为汇点做源-汇最大流，求出一组可行流；然后删去 $S,T$ 点，在可行流的基础上做以 $s$ 为源点、$t$ 为汇点的源-汇最大流

最小割模型

最小割问题

最大流 = 最小割

最大权闭合子图

闭合子图：对于有向图，我们选一些点，若 $u$ 被选，则任意 $u$ 连出的点 $v$ 都被选。

最大权闭合子图：每个点有点权，要求闭合子图点权和最大

• 设原图 $=(V,E)$，点 $u$ 权值为 $a_u$，边权为 $c$
• 建点 $s,t$，每个点 $u$ 建点 $p_u$
• $\forall u\in V,a_u>0$，建边 $s\to p_u$，$c=|a_u|$
• $\forall u\in V,a_u<0$，建边 $p_u\to t$，$c=|a_u|$
• $\forall(u,v)\in E$，建边 $p_u\to p_v$，$c=+\infty$
• 答案 $=$ 正点权和 $-$ 最小割

正确性：

• 先把所有正点权给选了
• $S$ 集合表示选的点集，$T$ 集合表示不选的点集
• 第 3 类边表示，若 $u$ 选了，$v$ 也必须选
• 第 1 类边表示，若正权点 $u$ 不被选，代价增加 $|a_u|$
• 第 2 类边表示，若负权点 $u$ 被选，代价增加 $|a_u|$

最小点割集

一张图，给出 $s,t$，每个点有正点权，求一个不包含 $s,t$ 的权值和最小的点集，使得删掉点集中所有点后 $s$ 无法到达 $t$。

• 把点拆成入点和出点，入点向出点连边，边权为该点点权
• 原图边从出点连向入点，边权为 $+\infty$
• 最小割即为答案

最小冲突投票

例题：BZOJ 1934

$n$ 个人，$m$ 对好友关系，每个人可以给 A 或 B 投票，每个人都有自己的意愿（倾向于 A 还是 B）。

定义一次投票的冲突数为“好友之间投票冲突的总数”加上“和自己本来意愿发生冲突的人数”，问如何投票，冲突数最小。

• 令 $S$ 表示投 A 的集合，$T$ 表示投 B 的集合，$c$ 为边权
• 建点 $s,t$
• $\forall i\in[1..n]$：
  • 若 $i$ 想投 A，$s\to i$，$c=1$
  • 若 $i$ 想投 B，$i\to t$，$c=1$
• 对于一对好友关系 $(u,v)$，连边 $u\leftrightarrow v$，$c=1$
• 最小割即为答案

组合收益

每个物品 $i$ 有收益 $a_i$（可以为负），若 $x_j,y_j$ 同时被选会额外获得收益 $v_j$，问最大收益。

• 先把所有正收益全选了
• 令 $S$ 集合表示选的物品，$T$ 集合表示没选的物品
• 每个组合 $j$ 建点 $p_j$
• 若 $a_i>0$，$s\to i$，$c=|a_i|$
• 若 $a_i<0$，$i\to t$，$c=|a_i|$
• $p_j\to x_j$、$p_j\to y_j$，$c=+\infty$
• 若 $v_j>0$，$s\to p_j$，$c=|v_j|$
• 若 $v_j<0$，$p_j\to t$，$c=|v_j|$
• 答案等于正收益之和减去最小割

黑白染色

把所有点分为两个集合，$i$ 在两个集合分别获得的收益为 $a_i,b_i$，如果 $x_j,y_j$ 所在集合不同会获得一个收益，否则会付出一个代价。

• 先把所有点黑白染色，分成两类点，需要满足同一类点之间没有限制条件
• 令 $S$ 为在第一个集合，$T$ 为在第二个集合
• 对于第一类收益：
• 对于黑色点，正常向 $s,t$ 连边
• 对于白色点，反转源汇，即把 $s$ 看成 $t$、把 $t$ 看成 $s$，然后连边
• 对于第二类收益：
• 问题变成了若所在集合相同则获得收益、所在集合不同则付出代价，正常连边即可
• 答案为所有收益之和减去最小割

最小割树

无向图最小割性质：设 $s,t$ 为任意两点，设 $s$ 到 $t$ 的最小割为 $c$，且把点分成了集合 $S$ 和 $T$，则 $\forall u\in S,v\in T$，$u$ 到 $v$ 的最小割 $\le c$

最小割树：点集中任取 $s,t$，在原图中跑出最小割 $c$ 把点集分成 $S,T$，按 $S,T$ 划分当前点集，向两边递归，再用一个权值为 $c$ 的点连接两边的点集，像 Kruskal 重构树一样

$u,v$ 最小割等于 $u,v$ 路径上的点权最小值.

证明考虑最小割的最小性和唯一性。

例题

最大密度子图

定义无向图 $G=(V,E)$ 的密度为 $\frac{|E|}{|V|}$，问子图的最大密度及方案。

• 二分答案 $g$，问题变成判定：有没有子图满足 $\frac{|E|}{|V|}\ge g$，即求出 $\max\{|E|-g|V|\}$
• 整理条件：
  • 选择子图时，如果选了某条边，那么他的两个端点也必须被选
  • 选了一条边，产生贡献 $1$
  • 选了一个点，产生贡献 $-g$
• 得出方法：
  • 把原图的点、边一律视为点
  • 从边变成的点向其两个端点连一条有向边
  • 将边的点权设为 $1$，点的点权设为 $-g$
  • 在新图中求出最大权闭合子图，答案就是我们要求的 $\max\{|E|-g|V|\}$
• 对于输出方案，把选了的点和边输出即可

最小权点覆盖

对于二分图，选一些点去覆盖他们相邻的边，使得所有边被覆盖，问选出的点权和最小是多少。

• 建点 $s,t$
• 对于所有左部点 $u$，$s\to u$，权值为 $u$ 的点权
• 对于所有右部点 $v$，$v\to t$，权值为 $v$ 的点权
• 对于原图边 $(u,v)$，$u\to v$，权值为 $+\infty$
• 求出最小割即为答案

这里割一条边就相当于选一个点

最大权独立集

等于总权值 $-$ 最小权点覆盖，之前证过。

习题

植物大战僵尸

最大权闭合子图。注意环。

奶牛的电信

最小点割集。

最小边异或和

• 首先按位考虑，每个点要么是 1，要么是 0，要么还没定，目标是最小化异或和
• 令 $S$ 为 0 集合，$T$ 为 1 集合
• 对于原图边 $(u,v)$：
  • 若两个点权已经给定，直接计入答案
  • 若给定一个点权，假设为 $v$：
  • 若 $a_v=0$，连边 $s\to u$，权值为 $1$
  • 若 $a_v=1$，连边 $u\to t$，权值为 $1$
  • 若两个点权都待定，连边 $u\leftrightarrow v$，权值为 $1$
• 最小割即为答案

逃出包围圈

最小点割集。

建图就是把上平面、下平面，以及每个圆看成一个点，把相交 / 相切关系看成一条边

猫狗大战

• 设 $S$ 为获奖的猫 / 不获奖的狗，$T$ 为不获奖的猫 / 获奖的狗
• 建点 $s,t$，猫 $i$ 建点 $c_i$，狗 $j$ 建点 $d_j$
• 对于所有猫 $u$，设其支持人数为 $r$，$s\to c_u$，$c=r$
• 对于所有狗 $v$，设其支持人数为 $r$，$d_v\to t$，$c=r$
• 对于所有猫 $u$、所有狗 $v$，设支持猫 $u$、不支持狗 $v$ 的猫粉数量，与不支持猫 $u$、支持狗 $v$ 的狗粉数量之和为 $r$，$c_u\leftrightarrow d_v$，$c=r$
• 总人数减去最小割即为答案

综合习题

无限之环

黑白染色 + 大力讨论 + 费用流

Code

#include <bits/stdc++.h>
using namespace std;
#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define reo(i, j, k) for (int i = (j); i >= (k); --i)
typedef long long ll;
const int N = 2001, dir[4][2] = {
	{-1, 0}, {0, 1}, {1, 0}, {0, -1}
};
const int INF = 0x3f3f3f3f;
vector<vector<array<int, 5>>> p;
vector<vector<int>> a, b;
int n, m, s, t;
 
struct Edge {
	int u, v, n, w, c;
} e[50001];
int pnode, pedge = 1, h[10001], cur[10001];
int SumF;
void add_edge(int u, int v, int w, int c) {
	e[++pedge] = {u, v, h[u], w, c}, h[u] = cur[u] = pedge;
}
void Add_edge(int u, int v, int w, int c, int d = 0) {
	if (d) swap(u, v);
	add_edge(u, v, w, c), add_edge(v, u, 0, -c);
}
void build_graph() {
	p.assign(n, vector<array<int, 5>>(m));
	b.assign(n, vector<int>(m));
	rep(i, 0, n - 1) 
		rep(j, 0, m - 1) 
			rep(k, 0, 4) 
				p[i][j][k] = ++pnode;
	s = ++pnode, t = ++pnode;
	rep(i, 0, n - 1)
		rep(j, 0, m - 1) 
			b[i][j] = (i + j) % 2;
	rep(i, 0, n - 1) {
		rep(j, 0, m - 1) {
			if (!b[i][j]) {
				rep(k, 0, 3) {
					int x = i + dir[k][0], y = j + dir[k][1];
					if (0 <= x && x <= n - 1 && 0 <= y && y <= m - 1) {
						Add_edge(p[i][j][k + 1], p[x][y][(k ^ 2) + 1], 1, 0);
						Add_edge(p[x][y][(k ^ 2) + 1], p[i][j][k + 1], 1, 0);
					}
				}
			}
		}
	}
	rep(i, 0, n - 1) {
		rep(j, 0, m - 1) {
			int d = __builtin_popcount(a[i][j]);
			if (b[i][j] == 0) {
				Add_edge(s, p[i][j][0], d, 0);
				SumF += d;
			} else {
				Add_edge(p[i][j][0], t, d, 0);
			}
		}
	}
	rep(i, 0, n - 1) {
		rep(j, 0, m - 1) {
			if (a[i][j] == 0) {
				;
			}
			if (a[i][j] == 1) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][2], 1, 1, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][4], 1, 1, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][3], 1, 2, b[i][j]);
			}
			if (a[i][j] == 2) {
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][1], 1, 1, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][3], 1, 1, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][4], 1, 2, b[i][j]);
			}
			if (a[i][j] == 3) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][3], 1, 1, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][4], 1, 1, b[i][j]);
			}
			if (a[i][j] == 4) {
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][4], 1, 1, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][2], 1, 1, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][1], 1, 2, b[i][j]);
			}
			if (a[i][j] == 5) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
			}
			if (a[i][j] == 6) {
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][4], 1, 1, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][1], 1, 1, b[i][j]);
			}
			if (a[i][j] == 7) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][4], 1, 1, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][4], 1, 1, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][4], 1, 2, b[i][j]);
			}
			if (a[i][j] == 8) {
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][1], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][3], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][2], 1, 2, b[i][j]);
			}
			if (a[i][j] == 9) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][3], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][2], 1, 1, b[i][j]);
			}
			if (a[i][j] == 10) {
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
			}
			if (a[i][j] == 11) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][3], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][3], 1, 1, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][3], 1, 2, b[i][j]);
			}
			if (a[i][j] == 12) {
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][1], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][2], 1, 1, b[i][j]);
			}
			if (a[i][j] == 13) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
				Add_edge(p[i][j][1], p[i][j][2], 1, 1, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][2], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][2], 1, 2, b[i][j]);
			}
			if (a[i][j] == 14) {
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
				Add_edge(p[i][j][2], p[i][j][1], 1, 1, b[i][j]);
				Add_edge(p[i][j][4], p[i][j][1], 1, 1, b[i][j]);
				Add_edge(p[i][j][3], p[i][j][1], 1, 2, b[i][j]);
			}
			if (a[i][j] == 15) {
				Add_edge(p[i][j][0], p[i][j][1], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][2], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][3], 1, 0, b[i][j]);
				Add_edge(p[i][j][0], p[i][j][4], 1, 0, b[i][j]);
			}
		}
	}
}
 
int nw, fa[10001], fe[10001], cir[10001], tag[10001];
int sum[10001];
void DFS(int u, int f, int c) {
	fa[u] = e[f].u, fe[u] = f, tag[u] = c;
	for (int i = h[u]; i; i = e[i].n)
		if (e[i].w && tag[e[i].v] != c) DFS(e[i].v, i, c);
}
int Sum(int u) {
	if (tag[u] == nw) return sum[u];
	return tag[u] = nw, sum[u] = Sum(fa[u]) + e[fe[u]].c;
}
int Push(int o) {
	int cnt = 0, del = 0, P = 2;
	int C = 0, F = e[o].w;
	++nw;
	int q = e[o].u, lca = e[o].v;
	while (q) tag[q] = nw, q = fa[q];
	while (tag[lca] != nw) tag[lca] = nw, lca = fa[lca];
	for (int u = e[o].u; u != lca; u = fa[u]) {
		cir[++cnt] = fe[u];
		if (e[fe[u]].w < F) F = e[fe[u]].w, del = u, P = 0;
	}
	for (int u = e[o].v; u != lca; u = fa[u]) {
		cir[++cnt] = fe[u] ^ 1;
		if (e[fe[u] ^ 1].w < F) F = e[fe[u] ^ 1].w, del = u, P = 1;
	}
	cir[++cnt] = o;
	rep(i, 1, cnt) C += F * e[cir[i]].c, e[cir[i]].w -= F, e[cir[i] ^ 1].w += F;
	if (P == 2) return C;
	int u = e[o].u, v = e[o].v;
	if (P) swap(u, v);
	int lste = o ^ P, lstu = v, tmp;
	while (lstu != del) {
		swap(fe[u], lste ^= 1), --tag[u];
		tmp = fa[u], fa[u] = lstu, lstu = u, u = tmp;
	}
	return C;
}
void Simplex() {
	Add_edge(t, s, INF, -INF);
	DFS(t, 0, ++nw), tag[t] = ++nw, fa[t] = 0;
	int F = 0, C = 0, ok = 1;
	while (ok) {
		ok = 0;
		rep(i, 2, pedge)
			if (e[i].w && e[i].c + Sum(e[i].u) - Sum(e[i].v) < 0)
				C += Push(i), ok = 1;
	}
	F = e[pedge].w;
	C += e[pedge].w * INF;
	if (F == SumF) {
		cout << C << '\n';
	} else {
		cout << "-1\n";
	}
}
 
int main() {
	ios::sync_with_stdio(false), cin.tie(nullptr);
	cin >> n >> m;
	a.assign(n, vector<int>(m));
	rep(i, 0, n - 1) {
		rep(j, 0, m - 1) {
			cin >> a[i][j];
		}
	}
	build_graph();
	Simplex();
	return 0;
}