[Noi2016]网格

来自FallDream的博客，未经允许，请勿转载，谢谢。

 

---

跳蚤国王和蛐蛐国王在玩一个游戏。

他们在一个 n 行 m 列的网格上排兵布阵。其中的 c 个格子中 (0≤c≤nm)，每个格子有一只蛐蛐，其余的格子中，每个格子有一只跳蚤。

我们称占据的格子有公共边的两只跳蚤是相邻的。

我们称两只跳蚤是连通的，当且仅当这两只跳蚤相邻，或存在另一只跳蚤与这两只跳蚤都连通。

现在，蛐蛐国王希望，将某些（0 个，1 个或多个）跳蚤替换成蛐蛐，使得在此之后存在至少两只跳蚤不连通。

例如：我们用图表示一只跳蚤，用图表示一只蛐蛐，那么图 1 描述了一个 n=4,m=4,c=2的情况。

这种情况下蛐蛐国王可以通过将第 2 行第 2 列，和第 3 行第 3 列的两只跳蚤替换为蛐蛐，从而达成他的希望，如图 2 所示。并且，不存在更优的方案，但是可能存在其他替换 2 只跳蚤的方案。

你需要首先判断蛐蛐国王的希望能否被达成。如果能够达成，你还需要最小化被替换的跳蚤的个数。

T<=20 1≤n,m≤10^9,0≤c≤min(nm,10^5) ∑c<=10^5

2s/1G

真是很蛋疼

当跳蚤数量小于2或者正好是一对还粘一起的时候答案是-1

当跳蚤本身不联通的时候答案是0

当存在一个点把图割开的时候是1

不然就是2

好像很简单 乱写了一通之后 成功获得了16分 真轻松  然后就去看了看题解

只保留在蛐蛐周围的5*5的格子内的跳蚤，四联通建图 建出的图等价 割点可以tarjan求出

然后如果有跳蚤不联通 那么会有一个蛐蛐的八联通块周围有两个不同的跳蚤联通块

感觉自己的码力不是很行啊  乱写一通 就这么丑了（吐血）

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#define ll long long
#define MN 100000
#define mod 2333333
using namespace std;
inline int read()
{
    int x = ; char ch = getchar();
    while(ch < '' || ch > '') ch = getchar();
    while(ch >= '' && ch <= ''){x = x *  + ch - '';ch = getchar();}
    return x;
}
int n,m,c,top,dn,ans,bel[MN*+],Cnt=,Col=,head[MN*+],en,tot,dfn[MN*+],low[MN*+],col[MN*+];
vector<int> v[MN+],V[MN+];
bool Cut[MN*+],b[MN+];
struct P
{
    int x,y;
    P(int x=,int y=):x(x),y(y){}
    P operator+(P b){return P(x+b.x,y+b.y);}
}p[MN+],Q[],q[MN*+];
struct edge{int to,next;}e[MN*+];
struct My_Map
{
    int Head[mod+],cnt;
    struct Hash{ll ha;int x,next;}s[*MN+];
    void clear()
    {
        cnt=;
        memset(Head,,sizeof(Head));
    }
    void ins(int X,int Y)
    {
        ll Ha=1LL*X*m+Y;int j=Ha%mod;
        s[++cnt]=(Hash){Ha,++Cnt,Head[j]};
        Head[j]=cnt;
    }
    int Check(int X,int Y)
    {
        ll Ha=1LL*X*m+Y;int j=Ha%mod;
        for(int i=Head[j];i;i=s[i].next)
            if(s[i].ha==Ha) return s[i].x;
        return ;
    }
}mp;
inline void ins(int f,int t){e[++en]=(edge){t,head[f]};head[f]=en;}
inline int abs(int x){return x<?-x:x;}
bool Check()
{
    if(1LL*n*m-c>) return false;
    if(1LL*n*m-c<=) return true;
    top=;
    for(int i=;i<=n;++i)
        for(int j=;j<=m&&top<;++j)
            if(!mp.Check(i,j)) Q[++top]=P(i,j);
    if(Q[].x==Q[].x&&abs(Q[].y-Q[].y)==) return true;
    if(Q[].y==Q[].y&&abs(Q[].x-Q[].x)==) return true;
    return false;
}
const int dis[][]={{,},{-,},{,},{,-}};
void build()
{
    for(int i=;i<=c;++i)
        for(int j=-;j<=;++j)
            for(int k=-;k<=;++k)
                if(j||k)
                {
                    int x=p[i].x+j,y=p[i].y+k;
                    if(x<=||y<=||x>n||y>m||mp.Check(x,y)) continue;
                    mp.ins(x,y);q[Cnt]=P(x,y);
                }
    for(int i=,k;i<=Cnt;++i)
        for(int j=;j<;++j)
        {
            int x=q[i].x+dis[j][],y=q[i].y+dis[j][];
            if(x<=||y<=||x>n||y>m||(k=mp.Check(x,y))<=) continue;
            ins(i,k);
        }
}

void tj(int x,int fa)
{
    dfn[x]=low[x]=++dn;bel[x]=tot;Cut[x]=;int son=;
    for(int i=head[x];i;i=e[i].next)if(e[i].to!=fa)
    {
        if(!dfn[e[i].to])
        {
            ++son,tj(e[i].to,x),low[x]=min(low[x],low[e[i].to]);
            if(low[e[i].to]>=dfn[x]) Cut[x]=;
        }
        else low[x]=min(low[x],dfn[e[i].to]);
    }
    if(son==&&!fa) Cut[x]=;
}

bool Round(int id)
{
    for(int i=-;i<=;++i)
        for(int j=-;j<=;++j)
            if(i||j)
            {
                int x=q[id].x+i,y=q[id].y+j;
                if(x&&y&&mp.Check(x,y)<)return ;
            }
    return ;
}

bool check(int t)
{
    int col=-;
    for(int l=;l<V[t].size();++l)
    {
        int X=p[V[t][l]].x,Y=p[V[t][l]].y;
        for(int i=-;i<=;++i)
            for(int j=-,k;j<=;++j)
                if(i||j)
                {
                    int x=X+i,y=Y+j;
                    if(x<||y<||x>n||y>m||(k=mp.Check(x,y))<) continue;
                    if(col==-) col=bel[k];
                    else if(col!=bel[k]) return true;
                }
    }
    return false;
}

void Dfs(int x)
{
    col[x]=Col;V[Col].push_back(x);
    for(int j=;j<v[x].size();++j)
        if(!col[v[x][j]]) Dfs(v[x][j]);
}

int main()
{
    for(int T=read();T;--T)
    {
        n=read();m=read();c=read();ans=;mp.clear();
        if(m==||n==) ans=;Cnt=-c-;
        for(int i=;i<=c;++i)
            p[i].x=read(),p[i].y=read(),mp.ins(p[i].x,p[i].y);
        if(Check()) puts("-1");
        else
        {
            Cnt=;en=;tot=;dn=;Col=;build();
            for(int i=,k;i<=c;++i)
                for(int j=;j<;++j)
                {
                    int x=p[i].x+dis[j][],y=p[i].y+dis[j][];
                    if(x<||y<||x>n||y>m) continue;
                    if((k=mp.Check(x,y))<) v[i].push_back(k+c+);
                }
            for(int i=;i<=c;++i)
                if(!col[i]) ++Col,Dfs(i);
            for(int i=;i<=Cnt;++i)
                if(!dfn[i]) ++tot,tj(i,);
            for(int i=;i<=Cnt&&ans>;++i) if(Cut[i]&&Round(i)) ans=;
            for(int i=;i<=Col&&ans;++i)
                if(check(i)) ans=;
            printf("%d\n",ans);
            memset(head,,sizeof(int)*(Cnt+));
            for(int i=;i<=c;++i) v[i].clear(),V[i].clear();
            memset(dfn,,sizeof(int)*(Cnt+));
            memset(low,,sizeof(int)*(Cnt+));
            memset(col,,sizeof(int)*(c+));
        }
    }
    return ;
}