bzoj 4651 网格

最新推荐文章于 2019-07-22 06:08:00 发布

我要吃熊猫

最新推荐文章于 2019-07-22 06:08:00 发布

阅读量442

点赞数

分类专栏： tarjan

本文链接：https://blog.csdn.net/chai_jing/article/details/74378623

版权

tarjan 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

4651: [Noi2016]网格

Time Limit: 50 Sec Memory Limit: 1024 MB
Submit: 147 Solved: 107
[ Submit][ Status][ Discuss]

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 列的一只跳蚤替换为蛐蛐，从而使得存在两只跳蚤不连通
并且不存在更优的方案。
对于第三组数据，最初已经存在两只跳蚤不连通，故不需要再进行替换。
对于第四组数据，由于最多只有一只跳蚤，所以无论如何替换都不能存在两只跳蚤不连通

HINT

Source

【分析】

摔。破题抄一年。

http://blog.csdn.net/crzbulabula/article/details/54016812

自己写不对...苦恼.jpg

【代码】

//NOI 2016 网格 
#include<bits/stdc++.h>
#define LL long long
#define M(a) memset(a,0,sizeof a)
#define fo(i,j,k) for(int i=j;i<=k;i++)
using namespace std;
const int mxn=2500005;
bool flag;
int n,m,c,T,tot,tim,num,cnt;
bool vis[mxn],bo[mxn],yes[mxn];
int dx[9]={0,-1,0,0,1,-1,-1,1,1};
int dy[9]={0,0,1,-1,0,1,-1,1,-1};
int bel[mxn],dfn[mxn],low[mxn],ccz[mxn];
struct point
{
	int x,y;
	bool operator < (const point &b) const
	{
		if(x<b.x) return 1;
		if(x>b.x) return 0;
		return y<b.y;
	}
}p[mxn],q[mxn];
vector <LL> v0[mxn],v1[mxn],node[mxn];
inline LL P(int x,int y) {return (LL)x*m+y;}
map <point,int> m1,m2;
inline int read()
{
	int x=0;char ch=getchar();
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
	return x;
}
inline void Dfs(int u)
{
	bel[u]=num;
	for(int i=0;i<v0[u].size();i++)
	{
		int v=v0[u][i];
		if(bo[v]) continue;
		bo[v]=1,Dfs(v);
	}
}
inline void dfs(int u,int fa)
{
	int son=0;
	ccz[u]=cnt;
	dfn[u]=low[u]=(++tim);
	for(int i=0;i<v1[u].size();i++)
	{
		int v=v1[u][i];
		if(v==fa) continue;
		if(!dfn[v])
		{
			dfs(v,u),son++;
			low[u]=min(low[u],low[v]);
			if(dfn[u]<=low[v]) yes[u]=1;
		}
		else low[u]=min(low[u],dfn[v]);
	}
	if(fa==0 && son==1) yes[u]=0;
}
inline bool check(int u)
{
	int nx=q[u].x,ny=q[u].y;
	fo(j,1,8)
	{
		int ex=nx+dx[j],ey=ny+dy[j];
		point tmp=(point){ex,ey};
//		printf("(%d %d) (%d %d)\n",nx,ny,ex,ey);
		if(m1.count(tmp)) return 1;
	}
	return 0;
}
inline bool connect()
{
	fo(i,1,c)
	  fo(j,1,8)
	  {
	  	  point g=(point){p[i].x+dx[j],p[i].y+dy[j]};
	  	  if(m1.count(g)) v0[i].push_back(m1[g]);
	  }
	fo(i,1,c) if(!bo[i]) bo[i]=1,num++,Dfs(i);
	fo(i,1,c) fo(x,-2,2) fo(y,-2,2)
	{
		point g=(point){p[i].x+x,p[i].y+y};
		if(g.x<=0 || g.x>n || g.y<=0 || g.y>m) continue;
		if(!m1.count(g) && !m2.count(g))
		{
			q[++tot]=g,m2[g]=tot;
			node[bel[i]].push_back(tot);
		}
	}
	fo(i,1,tot) fo(j,1,4)
	{
		point g=(point){q[i].x+dx[j],q[i].y+dy[j]};
		if(m2.count(g)) v1[i].push_back(m2[g]);
	}
	fo(i,1,tot) if(!dfn[i]) cnt++,dfs(i,0);
	fo(i,1,tot) if(yes[i] && check(i)) flag=1;
	fo(i,1,num) for(int j=1;j<node[i].size();j++)
	{
		int now=node[i][j],pre=node[i][j-1];
		if(ccz[now]!=ccz[pre]) return 0;
	}
	return 1;
}
inline void clear()
{
	m1.clear(),m2.clear();
	fo(i,1,c) v0[i].clear(),bo[i]=bel[i]=0;
	fo(i,1,c) node[i].clear();
	fo(i,1,tot) dfn[i]=low[i]=yes[i]=0;
	fo(i,1,tot) v1[i].clear();
	tot=tim=num=cnt=flag=0;
}
int main()
{
	T=read();
	while(T--)
	{
		clear();
		n=read(),m=read(),c=read();
		fo(i,1,c)
		{
			p[i].x=read(),p[i].y=read();
			m1[p[i]]=i;
		}
		if((LL)n*m-c<=1) {puts("-1");continue;}
		if(!connect()) {puts("0");continue;}
		if((LL)n*m-c==2) {puts("-1");continue;}
		if(n==1 || m==1) flag=1;
		if(flag) puts("1");else puts("2");
	}
	return 0;
}
/*
1
1000000000 1000000000 2
1 999999999
2 1000000000
*/