Description
Blinker最近喜欢上一个奇怪的游戏。
这个游戏在一个 N*M 的棋盘上玩,每个格子有一个数。每次 Blinker 会选择两个相邻
的格子,并使这两个数都加上 1。
现在 Blinker 想知道最少多少次能使棋盘上的数都变成同一个数,如果永远不能变成同
一个数则输出-1。
Solution
个人觉得这道网络流是最近刷到比较难的,它的建模很有借鉴意义。
先把格子黑白染色(因为每次染相邻两个格子这样就可以连边了)
首先我们按格子数量分奇偶讨论。
先设几个变量:
设最后都变成了
x
,白格上数的和为
当格子是奇数个
(n∗m ≡1 (mod 2)):
白格数量为
cnt1
,黑格为
cnt1+1
cnt1∗x−sum1=(cnt1+1)∗x−sum2
解得
x = sum2−sum1
然后用网络流check一下
当格子个数是偶数
(n ≡ 1 (mod) 2 | | m ≡ 1 (mod) 2)
二分
x
即
x2
是满足的。
关于怎么用网络流check
对于黑色格子,
src
向其连一条边,容量为
A[i][j]−x
对于白色格子,向
sink
连一条边,容量为
A[i][j]−x
然后每个黑色格子向四周的白格连一条边,容量为INF
check的时候观察流入是否等于流出。
这个建模说出来很简单,但是实际上个人觉得并不明显。
借鉴意义在于那个染色并且连边,格子的题好像很多都有这么干过。
code
/**************************************************************
Problem: 2756
User: bblss123
Language: C++
Result: Accepted
Time:12972 ms
Memory:1940 kb
****************************************************************/
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
const int M=2005;
const int N=1e4+5;
const ll INF=1ll<<50;
struct Edge{
int to;ll cap;int nxt;
}edge[N<<2];
int A[45][45];
int _,n,m,head[M],work[M],tot_edge,src,sink,dist[M];
inline void Max(int &a,int b){if(a<b)a=b;}
inline void add_edge(int from,int to,ll c){
edge[tot_edge]=(Edge){to,c,head[from]};
head[from]=tot_edge++;
edge[tot_edge]=(Edge){from,0,head[to]};
head[to]=tot_edge++;
}
queue<int>que;
bool bfs(){
for(int i=0;i<=sink;++i)
dist[i]=-1;
dist[src]=0;
que.push(src);
for(;!que.empty();){
int v=que.front();que.pop();
for(int i=head[v];~i;i=edge[i].nxt){
int to=edge[i].to;
if(dist[to]==-1&&edge[i].cap){
dist[to]=dist[v]+1;
que.push(to);
}
}
}
return dist[sink]!=-1;
}
bool mark[M],clr[45][45];
ll dfs(int v,ll f){
if(v==sink)return f;
mark[v]=1;
for(int &i=work[v];~i;i=edge[i].nxt){
int to=edge[i].to;
if(edge[i].cap&&dist[to]==dist[v]+1&&!mark[to]){
ll d=dfs(to,min(f,edge[i].cap));
if(d){
edge[i].cap-=d;
edge[i^1].cap+=d;
return d;
}
}
}
return 0;
}
inline ll Dinic(){
ll res=0;
for(;bfs();){
for(int i=0;i<=sink;++i)
work[i]=head[i];
for(;;){
for(int i=0;i<=sink;++i)
mark[i]=0;
ll f=dfs(src,INF);
if(!f)break;
res+=f;
}
}
return res;
}
inline int hash(int i,int j){return (i-1)*m+j;}
int rx[]={1,0,-1,0};
int ry[]={0,1,0,-1};
inline bool Legal(int &x,int &y){return x>=1&&x<=n&&y>=1&&y<=m;}
inline bool check(ll s){
memset(head,-1,sizeof(head));
tot_edge=0;
//Init
src=0,sink=n*m+1;
ll res=0,w=0;
for(int i=1;i<=n;++i)
for(int j=1;j<=m;++j){
if(clr[i][j]){
add_edge(src,hash(i,j),s-A[i][j]);
for(int k=0;k<4;++k){
int tx=i+rx[k],ty=j+ry[k];
if(Legal(tx,ty))add_edge(hash(i,j),hash(tx,ty),INF);
}
res+=(ll)s-A[i][j];
}
else{
add_edge(hash(i,j),sink,s-A[i][j]);
w+=s-A[i][j];
}
}
ll flow=Dinic();
return flow==res&&flow==w;
}
inline void gao(){
scanf("%d %d",&n,&m);
int Mx=0;
ll tot=0;
for(int i=1;i<=m;++i)
clr[1][i]=clr[1][i-1]^1;
for(int i=1;i<=n;++i)
for(int j=1;j<=m;++j){
scanf("%d",&A[i][j]);
Max(Mx,A[i][j]);
tot+=A[i][j];
if(i^1)clr[i][j]=clr[i-1][j]^1;
}
if(n*m%2==0){
ll l=Mx,r=INF,ans=-1;
for(ll mid;l<=r;){
mid=l+r>>1ll;
if(check(mid))ans=mid,r=mid-1;
else l=mid+1;
}
if(~ans)ans=1ll*ans*n*m-tot>>1LL;
printf("%lld\n",ans);
}
else{
ll sum[2]={0};
for(int i=1;i<=n;++i)
for(int j=1;j<=m;++j)
sum[clr[i][j]]+=A[i][j];
ll x=sum[1]-sum[0];
ll ans=x*n*m-tot>>1;
if(x<Mx)puts("-1");
else printf("%lld\n",check(x)?ans:-1);
}
}
int main(){for(scanf("%d",&_);_--;)gao();}