[BZOJ4651][NOI2016]网格-割点-并查集

网格

Description

跳蚤国王和蛐蛐国王在玩一个游戏。
他们在一个 n 行 m 列的网格上排兵布阵。其中的 c 个格子中 (0≤c≤nm)，每个格子有一只蛐蛐，其余的格子中，每个格子有一只跳蚤。
我们称占据的格子有公共边的两只跳蚤是相邻的。
我们称两只跳蚤是连通的，当且仅当这两只跳蚤相邻，或存在另一只跳蚤与这两只跳蚤都连通。
现在，蛐蛐国王希望，将某些（0 个，1 个或多个）跳蚤替换成蛐蛐，使得在此之后存在至少两只跳蚤不连通。
例如：我们用图表示一只跳蚤，用图表示一只蛐蛐，那么图 1 描述了一个 n=4,m=4,c=2的情况。
这种情况下蛐蛐国王可以通过将第 2 行第 2 列，和第 3 行第 3 列的两只跳蚤替换为蛐蛐，从而达成他的希望，如图 2 所示。并且，不存在更优的方案，但是可能存在其他替换 2 只跳蚤的方案。
你需要首先判断蛐蛐国王的希望能否被达成。如果能够达成，你还需要最小化被替换的跳蚤的个数。

Input

每个输入文件包含多组数据。
输入文件的第一行只有一个整数 TT，表示数据的组数。保证 1≤T≤20。
接下来依次输入 TT 组数据，每组数据的第一行包含三个整数 n, m, c。
保证1≤n,m≤10^9,0≤c≤min(nm,105)
接下来 c行，每行包含两个整数 x, y表示第 x 行，第 y 列的格子被一个蛐蛐占据（1≤x≤n,1≤y≤m）每一组数据当中，同一个蛐蛐不会被多次描述。
同一行相邻的整数之间由一个空格隔开。
1≤n,m≤10^9, 0≤c≤nm, 1≤x≤n, 1≤y≤m
1≤T≤20。我们记 ∑c为某个测试点中，其 T 组输入数据的所有 c 的总和,∑c≤10^5

Output

对于每一组数据依次输出一行答案。
如果这组数据中，蛐蛐国王的希望不能被达成，输出-1。否则，输出被替换的跳蚤的个数的最小值

Sample Input

4
4 4 2
1 1
4 4
2 3 1
1 2
2 2 2
1 1
2 2
1 1 0

Sample Output

2
1
0
-1

explanation

第一组数据就是问题描述中的例子。

对于第二组数据，可以将第 2 行第 2 列的一只跳蚤替换为蛐蛐，从而使得存在两只跳蚤不连通

并且不存在更优的方案。

对于第三组数据，最初已经存在两只跳蚤不连通，故不需要再进行替换。

对于第四组数据，由于最多只有一只跳蚤，所以无论如何替换都不能存在两只跳蚤不连通

---

作为人形自走巨大常数，写完后在LOJ卡了一会常后无果。
抱着弃疗的心情往BZOJ一交——
居然过了???

---

思路:

首先稍作分析便可看出，$ans\le 2$。
也就是说， a n s ∈ { − 1 , 0 , 1 , 2 } ans \in \{-1,0,1,2\} ans∈{−1,0,1,2}。

那么分类讨论一下吧。

对于$ans=-1$的情况，显然只有两种局面:只有一只跳蚤，或者只有两只跳蚤且两只跳蚤相邻。
这些是可以直接特判的。
对于$ans=0$，显然是原图已经出现了不连通的状况。
对于$ans=1$，那么原图存在一个点，使得删去这个点后图不联通，即原图存在割点。
否则$ans=2$。

$ans=-1$是可以直接特判的。
对于其他的情况，就需要用到给出图的连通性相关的信息了。
然而由于数据范围，直接建出图是不现实的。

考虑建出这样的一张新图，图上包含与每个蛐蛐距离不超过$2$(5*5)的所有格子，每个跳蚤格子向它的四联通跳蚤格子连边。
如下图:

...........
...00000...
...00000...
...0010000.
...0000000.
...0000100.
.....00000.

其中$1$是蛐蛐，$0$是被加入新图的格子。

可以发现，对于任意一种使原图不联通的蛐蛐放置方案，都会使新图不连通，而当原图联通时，新图一定联通。
这样，这张新图很好地代表了原图的信息。

注意，如果只包含了距离不超过$1$(3*3)的格子，会出现特殊情况使得原图的连通性与新图不同，无法起到替代作用。
如图:

.....|
...00|
...X1|
...00|
.....|

可以发现，在这种建法下，$X$作为新图的一个割点，却并不是原图的一个割点。

同时，并非所有割点均是有效的，只有那些与至少一只蛐蛐八连通意义下相邻的割点才是有效的、可以使答案变成$1$的割点。

对于找割点方面，tarjan即可。

细节较为繁琐，但思路清晰的情况下还挺好写的。
另外很吃常数，没有BZOJ的总时限像咱这种写$map$的怕是很难卡过去~

#include<bits/stdc++.h>
#include<tr1/unordered_map>
using namespace std;

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

typedef long long ll;
typedef pair<int,int> pr;
#define x first
#define y second
const int C=1e5+9;
const int N=25*C+9;
const int dx[]={0,1,0,-1,1,1,-1,-1};
const int dy[]={1,0,-1,0,1,-1,1,-1};

struct prhash
{
    template <class T1, class T2>
        std::size_t operator () (const std::pair<T1, T2> &p) const
        {
            return (p.first*10000000000ll)^p.second;
        }
};

pr p[C];
int n,m,c,tot;
vector<int> g[N];
int fa[N],lv[N],cflag;
int pre[N],low[N],dfn;
tr1::unordered_map<pr,int,prhash> ha,hath;

inline bool in(pr a){return 1<=a.x && a.x<=n && 1<=a.y && a.y<=m;}
inline int find(int x){return fa[x]=fa[x]==x?x:find(fa[x]);}

inline bool merge(int a,int b)
{
    if(find(a)==find(b))return 0;
    fa[find(a)]=find(b);return 1;
}

inline bool build_graph()
{
    tot=0;
    ha.clear();
    hath.clear();

    for(int i=1;i<=c;i++)
        hath[p[i]]=i;

    for(int i=1;i<=c;i++)
        for(int j=0;j<=7;j++)
        {
            pr nxt=pr(p[i].x+dx[j],p[i].y+dy[j]);
            if(!in(nxt) || hath.count(nxt) || ha.count(nxt))continue;
            ha[nxt]=++tot;g[tot].clear();fa[tot]=tot;lv[tot]=1;
        }

    for(int i=1;i<=c;i++)
        for(int j=-2;j<=2;j++)
            for(int k=-2;k<=2;k++)
            {
                pr nxt=pr(p[i].x+j,p[i].y+k);
                if(!in(nxt) || hath.count(nxt) || ha.count(nxt))continue;
                ha[nxt]=++tot;fa[tot]=tot;lv[tot]=2;
                g[tot].clear();
            }

    for(tr1::unordered_map<pr,int,prhash>::iterator it=ha.begin();it!=ha.end();it++)
    {
        pr now=(*it).first;int nowid=(*it).second;
        for(int l=0;l<=3;l++)
        {
            pr nxt=pr(now.x+dx[l],now.y+dy[l]);
            if(!in(nxt) || hath.count(nxt) || !ha.count(nxt))continue;
            int nxtid=ha[nxt];
            g[nowid].push_back(nxtid);
            merge(nowid,nxtid);
        }
    }

    for(int i=1;i<=c;i++)
    {
        int cfa=-1;
        for(int j=-2;j<=2;j++)
            for(int k=-2;k<=2;k++)
            {
                pr now=pr(p[i].x+j,p[i].y+k);
                if(!in(now) || hath.count(now))continue;
                int nowid=ha[now];
                if(!(~cfa))cfa=find(nowid);
                else if(cfa!=find(nowid))
                    return 0;
            }
    }

    return 1;
}

inline bool two_point()
{
    pr mem=pr(-1,-1);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(!hath.count(pr(i,j)))
            {
                if(!(~mem.x))
                    mem=pr(i,j);
                else if(abs(mem.x-i)+abs(mem.y-j)<=1)
                    return 1;
                else return 0;
            }
    return 0;
}

inline void dfs(int u,int fa)
{
    pre[u]=low[u]=++dfn;int cval=0,fl=0;
    for(int i=0;i<g[u].size();i++)
        if(!pre[g[u][i]])
        {
            cval++;dfs(g[u][i],u);
            if(low[g[u][i]]>=pre[u])
                fl=1;
            else low[u]=min(low[u],low[g[u][i]]);
        }
        else if(g[u][i]!=fa)
            low[u]=min(low[u],pre[g[u][i]]);
    if(!fa && cval==1)fl=0;
    if(fl && lv[u]==1)cflag=1;
}

inline int mina()
{
    n=read();m=read();c=read();
    for(int i=1;i<=c;i++)
        p[i].x=read(),p[i].y=read();

    if((ll)n*m-c<=1)return printf("-1"),0;
    if(!build_graph())return putchar('0'),0;
    if((ll)n*m-c<=2)return printf(two_point()?"-1":"0"),0;

    dfn=cflag=0;
    memset(pre,0,sizeof(pre[0])*(tot+9));
    memset(low,0,sizeof(low[0])*(tot+9));

    for(int i=1;i<=tot;i++)
        if(!pre[i])
            dfs(i,0);

    if(cflag || m==1 || n==1)
        return putchar('1'),0;
    return putchar('2'),0;
}

int main()
{
    for(int T=read();T;T--)
        mina(),putchar('\n');
    return 0;
}