[APIO2018] New Home 新家 题解

最新推荐文章于 2021-08-27 08:29:03 发布
最新推荐文章于 2021-08-27 08:29:03 发布
阅读量239 收藏
点赞数
分类专栏： 题解 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42925924/article/details/110069998
版权
题解 同时被 2 个专栏收录
119 篇文章 1 订阅
订阅专栏
算法
89 篇文章 1 订阅
订阅专栏
该博客介绍了如何使用离散化线段树解决一个复杂的问题：在一个动态变化的数轴上，每个点都有特定颜色，需要在任何时刻查询某个颜色点的最远距离。博客详细阐述了如何构建线段树，进行二分查找，并通过维护前驱点信息优化查询。还提供了两种不同复杂度的解决方案，分别是O(N×log²N)和O(N×logN)，并给出了完整的C++代码实现。
摘要由CSDN通过智能技术生成

[APIO2018] New Home 新家 题解

传送门

首先将时间离散化，然后依据时间建一棵线段树。将每一个店开业歇业时间搞到树上。

这样问题就转化为：有一个数轴每次加入或删除一个点。每一个点有一个颜色。在任意时间询问某一个点距离某一种颜色的最远距离。到某一个颜色的距离为到这个颜色的点的最小距离。

显然可以二分答案。每次询问区间 [ l , r ] [l,r] [l,r]是否包含了所有颜色的点。

对于每一个颜色我们搞一个set。记录每一个点到前面的那个同色的点，也就是前驱，记为pre[i]。

这个玩意的充要条件是在区间 [ l , ∞ ] [l,\infin] [l,∞] 的pre[i]都满足>=r。

对于这个我们也可以将坐标离散化搞到一个树上。

时间复杂度是 O ( N × log ⁡ 2 N ) O(N\times \log ^2 N) O(N×log2N)

这题也有单log的做法,就是在线段树上二分的地方的优化，不想多讲。

code:

(这个代码被卡常了我也懒得改了)

#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
inline int read()
{
	int num = 0, f = 1;
	char ch = getchar();
	while( !isdigit( ch ) ) { if(ch == '-') f = -1; ch = getchar(); }
	while( isdigit( ch ) ) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
	return num * f;
}
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
/*}
*/ 
const int MAXN=6e5+20;
int n,k,q;
vector<mp> sor; 
vector<int> pos_;
int x[MAXN],t[MAXN],a[MAXN],b[MAXN],l[MAXN],y[MAXN];
map<int,int> M;
int find(int f){
	//第一个>=f的位置
	return lower_bound(ALL(pos_),f)-pos_.begin()+1; 
}
const int N=1<<20;
int rest[MAXN];

struct SEGMENTTREE{
	int tree[N+N];//最小 
	SEGMENTTREE(){
		memset(tree,63,sizeof(tree));
	} 
	void modify(int index,int val){
		index+=N-1;
		tree[index]=val;
		index>>=1;
		while(index){
			tree[index]=min(tree[index<<1],tree[index<<1|1]);
			index>>=1;
		}
	}
	int query(int a,int b,int now=1,int l=1,int r=N+1){
		if(r<=a||l>=b){
			return INF;
		}
		if(r<=b&&l>=a){
			return tree[now];
		}
		int mid=(l+r)>>1;
		return min(query(a,b,now<<1,l,mid),query(a,b,now<<1|1,mid,r));
	}
}sgt;
set<int> pos[MAXN];
void add(int x_,int t_){
	pos[t_].insert(x_);
	auto ite=pos[t_].upper_bound(x_);
	if(ite!=pos[t_].end()){
		sgt.modify(*ite,x_);
	}
	ite=pos[t_].lower_bound(x_);
	if(ite!=pos[t_].begin()){
		ite--;
		sgt.modify(x_,*ite);
	}
	else {
		sgt.modify(x_,-INF);
	}
}
void del(int x_,int t_){
	sgt.modify(x_,INF);
	pos[t_].erase(x_);
	auto ite=pos[t_].upper_bound(x_);
	if(ite==pos[t_].end()) return;
	if(ite==pos[t_].begin()){
		sgt.modify(*ite,-INF);
	}
	else{
		int z=*ite;
		ite--;
		sgt.modify(z,*ite);
	}
}
bool check(int x_,int dis){
	int st=find(x_+dis+1);
	if(sgt.query(st,N+1)<find(x_-dis)) return 0;
	return 1;
}
struct EVENTSEGTREE{
	vector<int> tree[N+N];
	EVENTSEGTREE(){
		
	}
	void add_event(int st,int ed,int val,int now=1,int l=1,int r=N+1){
		if(r<=st||l>=ed){
			return ;
		}
		if(r<=ed&&l>=st){
			tree[now].PB(val);
			return ;
		}
		int mid=(l+r)>>1;
		add_event(st,ed,val,now<<1,l,mid);
		add_event(st,ed,val,now<<1|1,mid,r);
	}
	
	void run(int now=1,int l_=1,int r_=N+1){
		for(auto it:tree[now]){
			if(it>0){
				add(x[it],t[it]);
			}	
		}
		if(l_==r_-1){
			for(auto it:tree[now]){
				if(it<0){
					int lb=0,rb=1e8+1;
					if(!check(l[-it],rb)){
						rest[-it]=-1;
					}
					else{
						while(lb<rb){
							int mid=(lb+rb)>>1;
							if(check(l[-it],mid)) rb=mid;
							else lb=mid+1;
						}
						rest[-it]=lb;
					}
				}
			}
		}
		else{
			int mid=(l_+r_)>>1;
			run(now<<1,l_,mid);
			run(now<<1|1,mid,r_);
		}
		for(auto it:tree[now]){
			if(it>0){
				del(x[it],t[it]);
			}
		}
	}
}esgt;
int main(){
//	scanf("%d%d%d",&n,&k,&q);
	n=read();
	k=read();
	q=read();
	rb(i,1,n){
		int xi,ti,ai,bi;
//		scanf("%d%d%d%d",&xi,&ti,&ai,&bi);
		xi=read();
		ti=read();
		ai=read();
		bi=read();
		a[i]=ai;
		b[i]=bi;
		M[ai]=M[bi]=1;
		t[i]=ti;
		sor.PB(II(xi,i));
	}	
	rb(i,1,q){
		l[i]=read();
		y[i]=read();
	}
	rb(i,1,q){
//		scanf("%d%d",&l[i],&y[i]);
		M[y[i]]=1;
	}
	rb(i,1,k){
		n++;
		a[n]=-INF;
		b[n]=INF;
		M[a[n]]=M[b[n]]=1;
		x[n]=INF;
		t[n]=i;
		sor.PB(II(x[n],n));
	}
	sort(ALL(sor));
	rep(i,n){
		x[sor[i].SEC]=i+1;
		pos_.PB(sor[i].FIR);
	}
	int cnt=0;
	for(auto ite=M.begin();ite!=M.end();ite++){
		ite->SEC=++cnt;
	}
	rb(i,1,n){
		a[i]=M[a[i]];
		b[i]=M[b[i]];
		esgt.add_event(a[i],b[i]+1,i);
	}
	rb(i,1,q){
		y[i]=M[y[i]];
		esgt.add_event(y[i],y[i]+1,-i);
	}
	esgt.run();
	rb(i,1,q){
		printf("%d\n",rest[i]);
	}
	return 0;
}

UPDATE:

还是补充一下 O ( N × log ⁡ N ) O(N\times \log N) O(N×logN)的做法吧，(UOJ 已ac！)

#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
inline int read()
{
	int num = 0, f = 1;
	char ch = getchar();
	while( !isdigit( ch ) ) { if(ch == '-') f = -1; ch = getchar(); }
	while( isdigit( ch ) ) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
	return num * f;
}
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
/*}
*/ 
const int MAXN=6e5+20;
int n,k,q;
vector<mp> sor; 
vector<int> pos_;
int x[MAXN],t[MAXN],a[MAXN],b[MAXN],l[MAXN],y[MAXN];
map<int,int> M;
int find(int f){
	//第一个>=f的位置
	return lower_bound(ALL(pos_),f)-pos_.begin()+1; 
}
const int N=1<<20;
int rest[MAXN];

struct SEGMENTTREE{
	int tree[N+N];//最小 
	SEGMENTTREE(){
		memset(tree,63,sizeof(tree));
	} 
	void modify(int index,int val){
		index+=N-1;
		tree[index]=val;
		index>>=1;
		while(index){
			tree[index]=min(tree[index<<1],tree[index<<1|1]);
			index>>=1;
		}
	}
	int query(int a,int b,int now=1,int l=1,int r=N+1){
		if(r<=a||l>=b){
			return INF;
		}
		if(r<=b&&l>=a){
			return tree[now];
		}
		int mid=(l+r)>>1;
		return min(query(a,b,now<<1,l,mid),query(a,b,now<<1|1,mid,r));
	}
	int low_bound(int pos,int now=1,int l=1,int r=N+1,int MIN=INF){
		if(l==r-1) {
			int ret=INF;
			ret=min(ret,pos_[l-1]-pos);
			if(min(tree[now],MIN)>0)
			ret=min(ret,pos-pos_[min(tree[now],MIN)-1]);
			return ret;	
		}
		int mid=(l+r)>>1;
		if(mid>pos_.size()) return low_bound(pos,now<<1,l,mid,min(MIN,tree[now<<1|1]));
		if(pos_[mid-1]<=pos) return low_bound(pos,now<<1|1,mid,r,MIN);
		if(min(tree[now<<1|1],MIN)!=-INF&&(pos_[mid-2]-pos>=pos-pos_[min(tree[now<<1|1],MIN)-1])){
			return low_bound(pos,now<<1,l,mid,min(MIN,tree[now<<1|1]));
		}
		return low_bound(pos,now<<1|1,mid,r,MIN);
	}
}sgt;
set<int> pos[MAXN];
void add(int x_,int t_){
	pos[t_].insert(x_);
	auto ite=pos[t_].upper_bound(x_);
	if(ite!=pos[t_].end()){
		sgt.modify(*ite,x_);
	}
	ite=pos[t_].lower_bound(x_);
	if(ite!=pos[t_].begin()){
		ite--;
		sgt.modify(x_,*ite);
	}
	else {
		sgt.modify(x_,-INF);
	}
}
void del(int x_,int t_){
	sgt.modify(x_,INF);
	pos[t_].erase(x_);
	auto ite=pos[t_].upper_bound(x_);
	if(ite==pos[t_].end()) return;
	if(ite==pos[t_].begin()){
		sgt.modify(*ite,-INF);
	}
	else{
		int z=*ite;
		ite--;
		sgt.modify(z,*ite);
	}
}
bool check(int x_,int dis){
	int st=find(x_+dis+1);
	if(sgt.query(st,N+1)<find(x_-dis)) return 0;
	return 1;
}
int main(){
//	scanf("%d%d%d",&n,&k,&q);
	n=read();
	k=read();
	q=read();
	rb(i,1,n){
		int xi,ti,ai,bi;
//		scanf("%d%d%d%d",&xi,&ti,&ai,&bi);
		xi=read();
		ti=read();
		ai=read();
		bi=read();
		a[i]=ai;
		b[i]=bi;
		M[ai]=M[bi]=1;
		t[i]=ti;
		sor.PB(II(xi,i));
	}	
	rb(i,1,q){
		l[i]=read();
		y[i]=read();
	}
	rb(i,1,q){
//		scanf("%d%d",&l[i],&y[i]);
		M[y[i]]=1;
	}
	rb(i,1,k){
		n++;
		a[n]=-INF;
		b[n]=INF;
		M[a[n]]=M[b[n]]=1;
		x[n]=INF;
		t[n]=i;
		sor.PB(II(x[n],n));
	}
	sort(ALL(sor));
	rep(i,n){
		x[sor[i].SEC]=i+1;
		pos_.PB(sor[i].FIR);
	}
	int cnt=0;
	for(auto ite=M.begin();ite!=M.end();ite++){
		ite->SEC=++cnt;
	}
	vector<mp> eve;
	rb(i,1,n){
		a[i]=M[a[i]];
		b[i]=M[b[i]];
		eve.PB(II(a[i],i-INF));
		eve.PB(II(b[i]+1,i));
	}
	rb(i,1,q){
		y[i]=M[y[i]];
		eve.PB(II(y[i],i+INF));
	}
	sort(ALL(eve));
	for(auto &it:eve){
		if(it.SEC<0){
			add(x[it.SEC+INF],t[it.SEC+INF]);
			continue;
		}
		if(it.SEC<INF){
			del(x[it.SEC],t[it.SEC]);
			continue;
		}
		it.SEC-=INF;
		int lb=0,rb=1e8+1;
		if(!check(l[it.SEC],rb)){
			rest[it.SEC]=-1;
		}
		else{
				rest[it.SEC]=sgt.low_bound(l[it.SEC]);
			}
	}
	rb(i,1,q){
		printf("%d\n",rest[i]);
	}
	return 0;
}
Gary_2005
关注
专栏目录
APIO2018T1 New Home 题解 吕欣
07-26
题目大意 在一个数轴上： 给定 N 个商店，每个商店有一个开业时间、关门时间、坐标和销售物品的种类 同时有 M 个询问，每个询问给你一个时间 t[i] 和地点 d[i]，试求在 t[i] 时刻，一个住在 d[i] 的人，为了买某种商品最远需要跑多长距离。
APIO2018资料
06-30
"APIO18BCsimple_new2.pptx"和"new_home.pptx"可能是针对特定问题或比赛的讲解材料，例如“B”或“C”题目的详细解析，或者是比赛前的培训课程内容。这些PPT可能会包含解题思路、代码示例和解题过程中需要注意的关键...
[APIO2018] New Home 新家
weixin_34111790的博客
02-23 135
扫描线+线段树+二分答案+set+STL 就是把区间数颜色做得很好 时间看成线段，扫描线 对于某一个询问位置x 二分答案转化，看区间内有没有k种颜色。。 一个区间数颜色的套路是，prei上一个该颜色出现位置 查[x-mid,x+mid]pre小于x-mid的有几个。 树套树！！（TLE飞起） 其实并不关心是哪些个，只关心是否有k种 对于(prei,i)开区间，一定没有i这个...
【LOJ2585】「APIO2018」新家
cz_xuyixuan的博客
05-23 767
【题目链接】点击打开链接【思路要点】对时间轴进行扫描线，在时间轴上的一段区间可以表示为一次插入操作和一次删除操作。问题被转化为：维护一个序列，支持在某处插入/删除一个数，以及询问以某个位置为中心，包含所有种类的数的区间的最小长度。对于询问，不难想到二分答案，二分答案后我们需要支持的是询问区间内是否出现了所有种类的数。对于每一种数，我们维护一个支持查询前驱后继的平衡树（std::set）。在序列上维...
APIO2018 新家
yzyyylx的博客
12-29 528
题面 题意 在一条路上有n家商店，每个商店有一个类型，在某段时间内在某个位置上存在，每次询问给出一个时间和一个地点，求该时间从该地点出发最少走多少路才可以到达任意一种类型的商店。 做法 首先可以离线处理，根据时间进行排序，那么没家商店就都可以看作是在某个时间加入，再从某个时间删除，并询问某个点到所有类型点的最小距离的最大值。 这个可以进行二分，这样问题就转化为了，询问此时某一段区间内是否存在所有类...
【APIO2018】新家 - 题解
weixin_30333885的博客
05-22 140
题目链接 【APIO2018】新家 做法 对于这种区间修改、单点询问的题目，可以将询问离线再扫描线。 考虑对于一个答案 $ ans_i $ 合法，当且仅当 $ (l_i + ans_i, INF) $ 中每种店上一次出现的位置不小于 $ l_i + ans_i $ 。对于每种店都开一个 multiset 即可维护前驱。 这样每一次加入/删除会需要区间修改前驱，代码难度大，考虑 $ (l_i + a...
APIO2018 T2T3 题解 陈俊锟 吕欣 张瑞喆
07-26
第二题 重复下列算法： 每次选出半径最大的圆 删除和它有交的所有圆 这里有交指圆盘公共区域不为 0 求每个圆是哪一次被删除的 第三题 先从简单的题开始 给出一张无向图 求有多少
(APIO2018)从DFA到后缀自动机_张云帆.pdf
07-29
本文件标题为“(APIO2018)从DFA到后缀自动机_张云帆.pdf”，该标题揭示文档所涉及的主要内容是关于从确定性有限自动机（DFA）到后缀自动机（SAM）的转换过程，并且提到了作者“张云帆”，同时标记了与信息学奥林匹克...
APIO2008.pdf
07-21
"APIO2008.pdf" 本文档是亚洲信息学奥林匹克竞赛（APIO）2008年的竞赛题目，包含三个问题，分别是珠链交换器、换器交和DNA。本文档详细介绍了每个问题的描述、输入格式、输出格式、时间限制和空间限制等信息。 ...
[APIO2018] New Home 新家(线段树，二分答案，离散化)
xmr_pursue_dreams的博客
01-12 158
[APIO2018] New Home 新家 Solution 对于时间轴我们直接离散化+扫描线，维护每一个商店的加入和删除。 对于询问(x,t)(x,t)(x,t)，不好直接回答，这里的关键一步是：我们要求的是kkk种商店最小距离的最大值，于是考虑二分答案。二分一个最大值midmidmid，那么kkk种商店必须都在[x−mid,x+mid][x-mid,x+mid][x−mid,x+mid]出现过。我们考虑对于每一个商店维护和它类型相同的商店的前驱。那么[x−mid,x+mid][x-mid,x+mid]
【LOJ2585】新家（APIO2018）-线段树+multiset
Maxwei_wzj的OI世界
06-25 330
测试地址：新家 做法：本题需要用到线段树+multiset。 这题题意有点复杂，先理一下：数轴上有一些带颜色的点，每个点会在某个特定的时间段出现，若干个询问，每次询问某个时刻上离一个坐标距离最远的颜色的距离。坐标和颜色的距离定义为，该坐标与当前出现的所有该颜色的点的最小距离。 理完了题意，就可以想题了。首先因为没有强制在线，所以显然将操作按时间排序，而且把某个时间段出现某个点变成两个操作：某...
洛谷P4632 [APIO2018] New Home 新家(动态开节点线段树 二分答案 扫描线 set)
weixin_34214500的博客
10-22 171
题意 题目链接 Sol 这题没有想象中的那么难，但也绝对不简单。 首先把所有的询问离线，按照出现的顺序。维护时间轴来处理每个询问 对于每个询问\((x_i, y_i)\)，可以二分答案\(mid\)。 问题转化为对于所有\(a_i \leqslant y_i \leqslant b_i\)的商店，\((x - mid, x + mid)\)内是否所有类型的商店都出现过 若都出现过，减小\(mid\...
【二分答案+线段树+平衡树/线段树分治】APIO2018新家
MEET YOU FIRST TIME
06-14 887
【题目】 原题地址 题目大意：太长了去看题面吧。 【题目分析】 一道看上去比较奇怪的题目，需要一定转化思想。 不过二分答案这个点还是比较显然的。 【解题思路】 对时间扫描的话，每间商店等价于插入操作和删除操作。 问题转化为支持插入/删除，询问以某个位置为重心包含所有不同数字的最小长度。 对于询问，显然我们可以二分答案。但是如何查询一个区间内是否出现所有种类的数？ 考虑出现的充要...
[APIO 2018] 新家
C202044zxy的博客
10-21 211
一、题目 点此看题 二、解法 不难发现答案具有单调性，所以对于每个询问都可以二分答案。 具体来说对于位置xxx，如果答案≥m\geq m≥m，那么等价于存在一种店在(x−m,x+m)(x-m,x+m)(x−m,x+m)不存在店，但是区间并不好维护，可以使用前驱来判断存在与否，那么等价于在[x+m,inf)[x+m,inf)[x+m,inf)存在店的前驱≤x−m\leq x-m≤x−m，那么我们只需要判断[x+m,inf)[x+m,inf)[x+m,inf)前驱的最小值mn≤x−mmn\leq x-mmn≤x
[APIO2018]新家
七代目鸽影
08-27 162
线段树还蛮难的嘛。
UOJ#414. 【APIO2018】新家
Cyhlnj
01-11 292
传送门 首先二分答案 midmidmid，问题变成求区间 [l−mid,r+mid][l-mid,r+mid][l−mid,r+mid] 在该年份的不同类型个数为 kkk 关于年份的限制可以离线下来 现在的问题就是区间数颜色，一个套路就是维护每个颜色的后继，即这个位置颜色的下一个位置 那么，如果有 (−∞,l−mid](-\infty,l-mid](−∞,l−mid] 的某一个值大于 r+midr...
luoguP4632 \[APIO2018\] New Home 新家 multiset+线段树+堆+二分答案
maxtir的博客
10-09 283
luoguP4632 [APIO2018] New Home 新家 题目描述 五福街是一条笔直的道路，这条道路可以看成一个数轴，街上每个建筑物的坐标都可以用一个整数来表示。小明是一位时光旅行者，他知道在这条街上，在过去现在和未来共有 nnn个商店出现。第 iii个商店可以使用四个整数 xi,ti,ai,bix_i, t_i, a_i, b_ixi​,ti​,ai​,bi​描述，它们分别表示：商店的...
[LOJ]#2585. 「APIO2018」新家 线段树+multiset
TYB的博客
12-26 190
题解： 容易想到按照时间轴扫过去，然后二分答案。但是我们需要判断一个区间内是否出现了所有类型的商店，这是个区间数颜色，只有离线才有比较高效的做法。但我们并不需要数颜色，而只是需要区间是否包含所有颜色，所以得到了下面的做法：在坐标轴最后加每类商店各一个，然后判断[L,R][L,R][L,R]是否包含所有颜色就可以转化为[R,inf)[R,inf)[R,inf)的前驱最小值是否小于LLL。前驱后继用m...
APIO2009竞赛试题解析-采油区域问题
"APIO2009试题-中文版，2014年的亚太地区信息学奥林匹克竞赛试题，包括三个题目：采油区域、会议中心、抢掠计划。" 在2009年的亚太地区信息学奥林匹克竞赛（APIO）中，参赛者面临的挑战之一是名为"采油区域"的问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值