BZOJ4651/UOJ220 [Noi2016]网格

最新推荐文章于 2024-11-07 16:21:11 发布
最新推荐文章于 2024-11-07 16:21:11 发布
阅读量148 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ljh2000-jump/p/6373541.html
版权

本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。

 

 

本文作者：ljh2000
作者博客：http://www.cnblogs.com/ljh2000-jump/
转载请注明出处，侵权必究，保留最终解释权！

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

 

 

正解：hash+tarjan求割点

解题报告：

　　这道题我当时在考场上很快反应过来答案只有可能是0、1、2、-1…

　　部分分我在讲题的时候已经详细说了，所以直接上正解好了嘿嘿嘿...

　　考虑如果有大量空行则显然是无用的，具体思考后发现，对于一个蛐蛐，只有上下两行，左右两列是有用的，深入思考发现，我们只需要考虑每个蛐蛐的周围24个格子即可，直接相邻的叫做一级空地，和一级空地相邻的叫二级空地。

　　官方题解给出了详细证明，不赘述其正确性，下面只讲做法：

　　无解的情况可以很容易处理：假设跳蚤数量<=1或者只有2个跳蚤且相邻则无解；

　　然后我们对于每个蛐蛐控制的范围，扣出所有的空地，按四联通建图，

　　0个的情况是当把所有的连通块弄出来之后，假设一个蛐蛐控制的范围内的点，有不连通的空地，则说明已经隔断了；

　　1的情况考虑本质是求出有无割点，对建出来的图中每个连通块跑tarjan，假如存在割点则答案是1；

　　上述情况均不满足，答案就是2。

 

　　但是很遗憾的是这么做只有60分，我WA了很久之后发现，割点只有在一级空地时才有效，在二级空地的情况是非法的！

　　加入这条判断之后就AC了...

 

　　这道题的细节比较多，似乎我为了方便写的是函数化形式，有点丑，而且代码长...

　　讲道理这道题只要概括出模型，算法还是很simple的，就是要想到不断地优化来降低图的大小。

 

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;
const int MOD = 400007;
const int MAXN = 200011;
const int Bas = 1000000007;
const int MAXM = 5000011;
int n,m,c,yi[12][2]={{1,0},{0,1},{-1,0},{0,-1}};
int father[MAXM],ans,top;
LL dui[MAXM];
struct Cricket{ int x,y; }b[MAXN];
struct Hash{	
	int ecnt,first[MOD+12],next[MAXM];
	LL to[MAXM];
	inline void init(){ ecnt=0;	memset(first,0,sizeof(first)); }
	inline void insert(LL x,LL y){
		LL num=(x*Bas+y); int cc=(int)(num%MOD);
		next[++ecnt]=first[cc]; first[cc]=ecnt; to[ecnt]=num;
	}

	inline int query(LL x,LL y){
		LL num=(x*Bas+y); int cc=(int)(num%MOD);
		for(int i=first[cc];i;i=next[i]) if(to[i]==num) return i;
		return -1;
	}
}mp1,mp2;

inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}

namespace Graph{
	const int maxn = 2400011;
	const int maxm = 10000011;
	int ecnt,first[maxn],to[maxm],next[maxm],dfn[maxn],low[maxn],cnt,kcnt,stack[maxn],stack_top;
	bool iscut[maxn],yiji[maxn];
	inline void init(){	ecnt=0; memset(first,0,sizeof(first)); memset(yiji,0,sizeof(yiji)); }
	inline int find(int x){ if(father[x]!=x) father[x]=find(father[x]); return father[x]; }
	/*inline int find(int x){
		stack_top=0;
		while(father[x]!=x) {
			stack[++stack_top]=x;
			x=father[x];
		}
		while(stack_top>0) {
			father[stack[stack_top]]=x;
			stack_top--;
		}
		return x;
	}*/
	inline void link(int x,int y){ 
		next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y; 
		next[++ecnt]=first[y]; first[y]=ecnt; to[ecnt]=x;
	}
	inline void tarjan(int x,int fa){
		dfn[x]=low[x]=++cnt; int size=0;
		for(int i=first[x];i;i=next[i]) {
			int v=to[i]; if(v==fa) continue;
			if(dfn[v]==-1) {
				size++;	tarjan(v,x);
				low[x]=min(low[x],low[v]);
				if(low[v]>=dfn[x]) iscut[x]=1;
			}
			else if(low[v]<low[x]) low[x]=low[v];
		}
		if(fa==-1 && size==1) iscut[x]=0;
	}
	inline void work(){
		if((LL)n*m-c==2 && mp2.ecnt==2) { if(to[first[1]]==2) { puts("-1"); return ; } }//特判只有相邻的两个的情况
		for(int i=1;i<=mp2.ecnt;i++) dfn[i]=low[i]=-1,iscut[i]=0; cnt=0; kcnt=0;
		for(int i=1;i<=mp2.ecnt;i++) if(dfn[i]==-1) { kcnt++,tarjan(i,-1); }
		if(n==1 || m==1) { puts("1"); return ; }//特判n、m等于1的情况
		for(int i=1;i<=mp2.ecnt;i++) if(yiji[i] && iscut[i]) { puts("1"); return ; }
		puts("2");
	}
}

inline void build(int inx,int iny){
	int nowx,nowy,nx,ny,nn;
	for(int i=-2;i<=2;i++)
		for(int j=-2;j<=2;j++) {
			if(i==0 && j==0) continue;
			nowx=inx+i; nowy=iny+j; if(nowx<=0 || nowy<=0 || nowx>n || nowy>m) continue;
			if(mp1.query(nowx,nowy)!=-1) continue; nn=mp2.query(nowx,nowy);
			if(nn!=-1) { if(abs(i)<=1 && abs(j)<=1) Graph::yiji[nn]=1;  continue; } 
			mp2.insert(nowx,nowy); nn=mp2.query(nowx,nowy);
			if(abs(i)<=1 && abs(j)<=1) Graph::yiji[nn]=1;
			for(int l=0;l<4;l++) {
				nx=nowx+yi[l][0]; ny=nowy+yi[l][1]; if(nx<=0 || ny<=0 || nx>n || ny>m) continue;
				if(mp1.query(nx,ny)!=-1) continue; if(mp2.query(nx,ny)==-1) continue;
				Graph::link(nn,mp2.query(nx,ny));
			}
		}
}

inline void check_init(){
	using namespace Graph;
	int r1,r2; for(int i=1;i<=mp2.ecnt;i++) father[i]=i;
	for(int i=1;i<=mp2.ecnt;i++)
		for(int j=first[i];j;j=next[j]) {
			if(to[j]<=i) continue;
			r1=find(i); r2=find(to[j]);
			if(r1!=r2) father[r1]=r2;
		}
}

inline void check(int inx,int iny){
	using namespace Graph;
	int nowx,nowy; top=0;
	for(int i=-2;i<=2;i++)
		for(int j=-2;j<=2;j++){
			if(i==0 && j==0) continue;
			nowx=inx+i; nowy=iny+j; if(nowx<=0 || nowy<=0 || nowx>n || nowy>m) continue;
			if(mp1.query(nowx,nowy)!=-1) continue;
			dui[++top]=mp2.query(nowx,nowy);
		}
	for(int i=2;i<=top;i++) if(find(dui[i])!=find(dui[1])) { ans=0; return ; }
}

inline void work(){
	int T=getint();
	while(T--) {
		n=getint(); m=getint(); c=getint(); 
		for(int i=1;i<=c;i++) b[i].x=getint(),b[i].y=getint();
		if((LL)n*m-c<=1) { puts("-1"); continue; }//特判无解
		if(c==0 && n*m==2) { puts("-1"); continue; }//特判只有相邻的两个的情况
		mp1.init(); mp2.init(); Graph::init(); ans=-1;
		for(int i=1;i<=c;i++) mp1.insert(b[i].x,b[i].y);
		for(int i=1;i<=c;i++) build(b[i].x,b[i].y);		
		//检查0的情况
		check_init(); 
		for(int i=1;i<=c;i++) { check(b[i].x,b[i].y); if(ans==0) break; }
		if(ans==0) { puts("0"); continue; }
		Graph::work();
	}
}

int main()
{
    work();
    return 0;
}

　　

 

　　

 

转载于:https://www.cnblogs.com/ljh2000-jump/p/6373541.html

dgoh41514
关注
【BZOJ】4652: [Noi2016]循环之美-数论
远行客
06-18 359
题解 数学公式什么的太难打了。 我们可以发现一个规律，设分母为n,进制为k,当n⊥kn⊥kn\perp k即gcd(n,k)=1gcd(n,k)=1gcd(n,k)=1时，该小数性质满足题目要求（并不会证） 可以得到：∑ni=1∑mj=1[i⊥j][j⊥k]∑i=1n∑j=1m[i⊥j][j⊥k]\sum_{i=1}^{n}\sum_{j=1}^{m}[i\perp j][j\perp k]...
【BZOJ4651】【UOJ220】【NOI2016】网格
cz_xuyixuan的博客
05-29 374
【题目链接】BZOJUOJ【思路要点】当且仅当跳蚤个数不足两个，或跳蚤个数为两个，并且他们位置相邻，答案为-1。否则，当且仅当原本跳蚤中存在不连通的跳蚤，答案为0。否则，当且仅当原图中存在割点，答案为1。否则答案为2。将整张图建出来，依次检验以上判断标准，可以得到一个时空复杂度为\(O(N*M)\)的做法。我们发现\(N\)和\(M\)均很大，而\(C\)很小，这意味着存在大面积的空白，考虑只考虑...
[UOJ#220][BZOJ4651][Noi2016]网格
weixin_30487701的博客
06-29 120
[UOJ#220][BZOJ4651][Noi2016]网格 试题描述 跳蚤国王和蛐蛐国王在玩一个游戏。 他们在一个 n 行 m 列的网格上排兵布阵。其中的 c 个格子中 (0≤c≤nm)，每个格子有一只蛐蛐，其余的格子中，每个格子有一只跳蚤。 我们称占据的格子有公共边的两只跳蚤是相邻的。 我们称两只跳蚤是连通的，当且仅当这两只跳蚤相邻，或存在另一只跳蚤与这两只跳蚤都连通。 现...
[BZOJ4651][NOI2016]网格(Tarjan)
weixin_30414245的博客
11-06 68
下面直接给出结论，相关证明见官方题解。 1.若跳蚤数不超过1或仅有两只跳蚤且相邻，则答案为-1。 2.若跳蚤形成的连通块个数大于1，则答案为0。 3.若跳蚤之间建图存在割点，则答案为1。 4.否则为2。 这样就有70分了。但是图太大了，显然有很多没用的跳蚤被统计进答案。 考虑到造成不连通的情况一定在蛐蛐附近，于是将每个蛐蛐周围5*5的格子中的24个跳蚤全部取出，内圈8个称为一...
[BZOJ4651][Noi2016]网格（Tarjan 求割点）
女装的你，如此好看！
04-01 267
Address 洛谷 P1173 BZOJ 4651 UOJ #220 LOJ #2084 Solution 下面把跳蚤视为白点，蛐蛐视为黑点 可以发现答案只可能是 −1-1−1 、 000 、 111 、 222 四种 然后随机输出一个，你可以以 1 / (4 ^ T) 的高概率通过此题 易得， 如果没有黑点，则有三种情况 （1） n×m≤2n\times m\le 2n×m≤2 ： −1...
【BZOJ4651】【NOI2016】网格（Tarjan，哈希）
weixin_30367873的博客
07-11 87
【BZOJ4651】【NOI2016】网格（Tarjan，哈希） 题面 BZOJ 洛谷 题解 首先把题目稍微变得好说一些，给定一个网格，已经删去了若干个格子 问最少删去多少个格子使得图不连通。 这题的关键是要看出答案一定只有\(-1,0,1,2\) 证明一下一定存在答案不超过二。 在不是无解的情况下，四个角上的答案一定不会超过\(2\) 假设四个角被删去了，那么在边界上一定存在一个未被删去的格子，...
【NOI2016】网格
LiuJunhao's Blog
02-18 1739
题目描述输入输出样例输入 4 4 2 1 1 4 4 2 3 1 1 2 2 2 2 1 1 2 2 1 1 0样例输出 2 1 0 -1分析我们很容易看出答案只有可能是2,1,0,-1。关于一些表述的解释 我们将蝈蝈所在格子称为障碍，其余格子称为空地。 根据题意，我们可以看做最外围也是一圈障碍，但是我们不去管它，一下所提到的障碍都不包括外围的一圈
并不对劲的bzoj4651:loj2084:uoj220:p1173:[NOI2016]网格
weixin_30323961的博客
02-17 145
题目大意 有一个\(n*m\)（\(n,m\leq10^9\)）的网格，每个格子是空地或障碍（\(障碍数\leq10^5\)） 定义两块空地连通，当且仅当它们是“相邻的两块空地”或“存在一块空地与这两块空地连通的两块空地”（也就是四连通） 求至少添加多少块障碍物，使存在两块空地不连通，或者输出-1表示无解 题解 当只有一块空地或只有两块相邻的空地时，无解 有解时，发现总能找到一个角落，使只用两个障...
BZOJ4651 & 洛谷1173 & UOJ220：[NOI2016]网格——题解（附debug数据）
weixin_33935505的博客
06-04 158
https://www.lydsy.com/JudgeOnline/problem.php?id=4651 https://www.luogu.org/problemnew/show/P1173#sub http://uoj.ac/problem/220 跳蚤国王和蛐蛐国王在玩一个游戏。 他们在一个 n 行 m 列的网格上排兵布阵。其中的 c 个格子中 (0≤c≤nm)，每个格子有...
[NOI 2016]网格
weixin_30730053的博客
07-04 127
Description 题库链接 给出一张 \(n\times m\) 的网格，在其中删去 \(c\) 个格子，问至少再删去几个能使得图上存在两点不连通，或输出无解。 多组询问，询问组数 \(T\) 。 \(1\leq T\leq 20,1\leq n,m\leq 10^9,\sum c\leq 10^5\) Solution 观察题目，容易发现答案只会在 \(-1,0,1,2\) 之间...
[BZOJ4664]Count/[JOI Open 2016]摩天大楼
StaroForgin的博客
02-26 251
楷皇言:easy dp
【总结】插头DP-bzoj1210/2310/2331/2595
远行客
11-25 378
插头DP小结
BZOJ3585/洛谷P4137 区间mex（主席树）
hipamp的博客
06-06 442
题意 有 nnn 个数 {an}\{a_n\}{an​}，有 mmm 个询问，每个询问给定 l,rl,rl,r，求 al,...,ara_l,...,a_ral​,...,ar​ 的 mexmexmex。（最小的未出现的自然数） 其中 n,m≤2e5,ai≤109n,m\leq 2e5,a_i\leq10^9n,m≤2e5,ai​≤109 分析 令 viv_ivi​ 表示 iii 最后出现的位置。用主席树维护 viv_ivi​。 那么对于一个询问 (l,r)(l,r)(l,r)，我们在 [1,r][1,r]
[bzoj5017/Snoi2017]炸弹
WorldWide_D的博客
10-23 769
题目大意在一条直线上有 N 个炸弹，每个炸弹的坐标是 Xi，爆炸半径是 Ri，当一个炸弹爆炸时，如果另一个炸弹所在位置 Xj 满足： Xi−Ri≤Xj≤Xi+Ri,那么，该炸弹也会被引爆。 对于i等于1到n，求把第i个炸弹引爆会导致多少个炸弹爆炸。n≤500000，|Xi|≤101810^{18}，0≤Ri≤2⋅10182·10^{18}，保证Xi严格递增分析首先引爆的炸弹肯定是一个区间。
算法基础-链表
August的专栏
11-05 227
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
决策树算法
hawk2014bj的博客
11-05 205
决策树根据交叉熵或者基尼指数对数据进行分类并最终生成决策树，可以应用一些相对确定的分类场景。
DFS求解迷宫最长移动路线
安祝老师的博客
11-05 1276
来源：十四届蓝桥杯STEMA考试Python真题试卷第二套第五题。本文给出了C++实现代码，介绍了 STL 中容器`vector`，`pair`，`unordered_set` 的应用，供信奥选手参考。**迷宫类问题**适合用**DFS算法**解决，本文最后总结了DFS算法的两种常见实现方式——**递归实现、栈实现**，应用场景——**迷宫类问题、图的连通性、树的遍历、拓朴排序、排列组合**，以及主要优缺点。
动态规划26：467. 环绕字符串中唯一的子字符串
最新发布
2301_76197086的博客
11-07 383
详解动态规划26：467. 环绕字符串中唯一的子字符串（子数组问题）
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 314
Leetcode 160. 相交链表
图论精华：从基础到进阶的NOI图论教程
"这是关于NOI（全国青少年信息学奥林匹克竞赛）图论知识的全面总结，适合不同程度的选手学习，从基础到高级逐步深入。内容涵盖了图的分类、基础图论概念、进阶图论技巧以及相关算法应用。" 在NOI的图论学习中，首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值