题目描述
跳蚤国王和蛐蛐国王在玩一个游戏。
他们在一个 n 行 m 列的网格上排兵布阵。其中的 c 个格子中 (0≤c≤n⋅m),每个格子有一只蛐蛐,其余的格子中,每个格子有一只跳蚤。
我们称占据的格子有公共边的两只跳蚤是相邻的。
我们称两只跳蚤是连通的,当且仅当这两只跳蚤相邻,或存在另一只跳蚤与这两只跳蚤都连通。
现在,蛐蛐国王希望,将某些(零个,一个或多个)跳蚤替换成蛐蛐,使得在此之后存在至少两只跳蚤不连通。
例如:图 11 描述了一个 n=4,m=4,c=2 的情况。
这种情况下蛐蛐国王可以通过将第二行第二列,和第三行第三列的两只跳蚤替换为蛐蛐,从而达成他的希望,如右图所示。并且,不存在更优的方案,但是可能存在其他替换两只跳蚤的方案。
你需要首先判断蛐蛐国王的希望能否被达成。如果能够达成,你还需要最小化被替换的跳蚤的个数。
输入格式
每个输入文件包含多组数据。
输入文件的第一行只有一个整数 T,表示数据的组数。
接下来依次输入 T 组数据,每组数据的第一行包含三个整数 n,m,c。
接下来 c 行,每行包含两个整数 x,y 表示第 x 行,第 y 列的格子被一个蛐蛐占据。每一组数据当中,同一个蛐蛐不会被多次描述。
输出格式
对于每一组数据依次输出一行答案。
如果这组数据中,蛐蛐国王的希望不能被达成,输出 −1−1。否则,输出被替换的跳蚤的个数的最小值。
输入输出样例
输入 #1复制
4 4 4 2 1 1 4 4 2 3 1 1 2 2 2 2 1 1 2 2 1 1 0
输出 #1复制
2 1 0 -1
说明/提示
样例解释
第一组数据就是问题描述中的例子。
对于第二组数据,可以将第二行第二列的一只跳蚤替换为蛐蛐,从而使得存在两只跳蚤不连通,并且不存在更优的方案。
对于第三组数据,最初已经存在两只跳蚤不连通,故不需要再进行替换。
对于第四组数据,由于最多只有一只跳蚤,所以无论如何替换都不能存在两只跳蚤不连通。
数据范围
对于全部的测试点,保证 1≤�≤201≤T≤20。我们记 ∑�∑c 为某个测试点中,其 �T 组输入数据的所有 �c 的总和。对于所有的测试点,∑�≤105∑c≤105。
对于全部的数据,满足 1≤�,�≤1091≤n,m≤109,0≤�≤�×�0≤c≤n×m,1≤�≤�,1≤�≤�1≤x≤n,1≤y≤m。
每个测试点的详细数据范围见下表。表中的 �,�,�n,m,c 均是对于单个输入数据(而非测试点)而言的,也就是说同一个测试点下的 �T 组数据均满足限制条件;而 ∑�∑c是对于单个测试点而言的。为了方便阅读,“测试点”一列被放到了表格的中间而不是左边。
n,m | 测试点 | �c |
---|---|---|
n∗m≤4 | 1 | c≤n∗m |
n∗m≤8 | 2 | c≤n∗m |
n∗m≤15 | 3 | c≤n∗m |
n∗m≤30 | 4 | c≤n∗m |
n∗m≤100 | 5 | c≤n∗m |
n∗m≤300 | 6 | c≤n∗m |
n∗m≤103 | 7 | c≤n∗m |
n∗m≤2×104 | 8 | c≤5 |
n∗m≤2×104 | 9 | c≤15 |
n∗m≤2×104 | 10 | c≤30 |
n,m≤2×104,n∗m≤2×104 | 11 | ∑c≤2×104 |
n,m≤2×104,n∗m≤105 | 12 | ∑c≤2×104 |
n,m≤2×104,n∗m≤3×105 | 13 | ∑c≤2×104 |
n,m≤2×104,n∗m≤106 | 14 | ∑c≤2×104 |
n,m≤2×104,n∗m≤109 | 15 | ∑c≤2×104 |
n,m≤105 | 16 | c≤105 |
n,m≤109 | 17 | c=0 |
n,m≤109 | 18 | c≤1 |
n,m≤109 | 19 | c≤2 |
n,m≤109 | 20 | c≤3 |
n,m≤109 | 21 | c≤10 |
n,m≤109 | 22 | c≤30 |
n,m≤109 | 23 | c≤300 |
n,m≤109 | 24 | ∑c≤2×104 |
n,m≤109 | 25 | ∑c≤105 |
AC:
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
typedef long long ll;
const int dx[4]={0,1,0,-1};
const int dy[4]={1,0,-1,0};
const int P=1000117;
const int N=100050;
char rB[1<<21],*rS,*rT;
inline char gc(){return rS==rT&&(rT=(rS=rB)+fread(rB,1,1<<21,stdin),rS==rT)?EOF:*rS++;}
inline int rd(){
char c=gc();
while(c<48||c>57)c=gc();
int x=c&15;
for(c=gc();c>=48&&c<=57;c=gc())x=(x<<3)+(x<<1)+(c&15);
return x;
}
int x[N],y[N],G[N*24],to[N*192],nxt[N*192],sz,cnt,pre[N*24],dfsc,n,m,c,tmpx[N*24],tmpy[N*24],ctmp;
bool isok[N*24],iscut[N*24];
struct node{
int x,y;
node(){}
node(int x,int y):x(x),y(y){}
};
queue<node> Q,q;
struct Hash{ //用hash实现map
int h[P],vx[N*25],vy[N*25],p[N*25],nxt[N*25],sz;
inline void clear(){
memset(h,0,sizeof(h));sz=0;
}
inline void ins(int x,int y,int id){
int pos=((ll)(x-1)*n+y-1)%P;
vx[++sz]=x;vy[sz]=y;p[sz]=id;nxt[sz]=h[pos];h[pos]=sz;
}
inline int ask(int x,int y){
for(int k=h[((ll)(x-1)*n+y-1)%P];k;k=nxt[k])if(vx[k]==x&&vy[k]==y)return p[k];
return 0;
}
}h,col,tem;
inline int Abs(int x){return x<0?-x:x;}
inline int Max(int a,int b){return a>b?a:b;}
inline void add(int u,int v){
to[++sz]=v;nxt[sz]=G[u];G[u]=sz;
to[++sz]=u;nxt[sz]=G[v];G[v]=sz;
}
inline bool check(){
int i,j,k,tx,ty;
for(i=1;i<=n;++i)
for(j=1;j<=m;++j)if(!h.ask(i,j)){
for(k=0;k<4;++k)if((tx=i+dx[k])&&tx<=n&&(ty=j+dy[k])&&ty<=m&&!h.ask(tx,ty))return 1;
return 0;
}
}
inline void bfs(int sx,int sy,int cl){ //第一次floodfill
int i,u,v,tx,ty;
q.push(node(sx,sy));col.ins(sx,sy,cl);
while(!q.empty()){
u=q.front().x;v=q.front().y;q.pop();
for(i=0;i<4;++i)if((tx=u+dx[i])&&tx<=n&&(ty=v+dy[i])&&ty<=m&&h.ask(tx,ty)>0&&!col.ask(tx,ty)){
col.ins(tx,ty,cl); //用col来记录所属联通块编号(也成为颜色)
q.push(node(tx,ty));
}
}
}
inline bool bfs2(int sx,int sy){
int i,u,v,x,y,t;
q.push(node(sx,sy));tem.ins(sx,sy,-1);
while(!q.empty()){
u=q.front().x;v=q.front().y;q.pop();
for(x=Max(1,u-1);x<=n&&x<=u+1;++x)
for(y=Max(1,v-1);y<=m&&y<=v+1;++y)if((t=h.ask(x,y))&&!tem.ask(x,y))if(t==-1){
tem.ins(x,y,-1); //用tem来防止对障碍结点重复访问
//对跳蚤结点的重复访问最多总共c*8个,不会影响复杂度
q.push(node(x,y));
}else{tmpx[++ctmp]=x;tmpy[ctmp]=y;}
}
if(ctmp==-1)return 1;
for(i=1,t=col.ask(tmpx[0],tmpy[0]);i<=ctmp;++i)if(col.ask(tmpx[i],tmpy[i])!=t)return 0;
return 1;
}
inline bool ncon(){ //判断是否不连通
int i,u,v,ccl=0;
col.clear();
while(!Q.empty()){
u=Q.front().x;v=Q.front().y;Q.pop();
if(col.ask(u,v))continue;
bfs(u,v,++ccl);
}
tem.clear();
for(i=0;i<c;++i)if(!tem.ask(x[i],y[i])){
ctmp=-1;
if(!bfs2(x[i],y[i]))return 1;
}
return 0;
}
int dfs(int u,int fa){ //dfs求割顶
int i,v,lowu=pre[u]=++dfsc,lowv,chd=0;
for(i=G[u];i;i=nxt[i])if((v=to[i])!=fa)if(!pre[v]){
++chd;
if((lowv=dfs(v,u))>=pre[u])iscut[u]=1;
if(lowv<lowu)lowu=lowv;
}else if(pre[v]<lowu)lowu=pre[v];
if(!fa&&chd==1)iscut[u]=0;
return lowu;
}
int main(){
int T=rd(),i,j,k,l,t,tt,tx,ty;
bool ok;
while(T--){
n=rd();m=rd();c=rd();
h.clear();
for(i=0;i<c;++i){
x[i]=rd();y[i]=rd();
h.ins(x[i],y[i],-1);
}
if((ll)n*m-c<2ll){
puts("-1");
continue;
}
if((ll)n*m-c==2ll){
puts(check()?"-1":"0");
continue;
}
memset(G,0,sizeof(G));ok=sz=cnt=dfsc=0;
memset(pre,0,sizeof(pre));
memset(iscut,0,sizeof(iscut));
memset(isok,0,sizeof(isok));
//建图
for(i=0;i<c;++i)
for(j=Max(1,x[i]-2);j<=x[i]+2&&j<=n;++j)
for(k=Max(1,y[i]-2);k<=y[i]+2&&k<=m;++k)if(!(t=h.ask(j,k))){
h.ins(j,k,++cnt);Q.push(node(j,k));
isok[cnt]=Max(Abs(j-x[i]),Abs(k-y[i]))<=1;
for(l=0;l<4;++l)if((tx=j+dx[l])&&tx<=n&&(ty=k+dy[l])&&ty<=m&&(tt=h.ask(tx,ty))>0)add(cnt,tt);
}else if(t>0&&Max(Abs(j-x[i]),Abs(k-y[i]))<=1)isok[t]=1;
if(ncon()){
puts("0");
continue;
}
if(n==1||m==1){ //一行或一列可以特判
puts("1");
continue;
}
for(i=1;i<=cnt;++i){
if(!pre[i])dfs(i,0);
if(isok[i]&&iscut[i]){
puts("1");
ok=1;break;
}
}
if(!ok)puts("2");
}
return 0;
}