JZM 的国赛路 Ⅱ（倍增+数据结构）

最新推荐文章于 2022-08-15 21:43:31 发布

DD(XYX)

最新推荐文章于 2022-08-15 21:43:31 发布

阅读量184

点赞数

分类专栏：二分/倍增模拟

本文链接：https://blog.csdn.net/weixin_43960414/article/details/115139731

版权

模拟同时被 2 个专栏收录

31 篇文章 1 订阅

订阅专栏

二分/倍增

20 篇文章 0 订阅

订阅专栏

题面

JZM 终于通过了那条单行道！

现在他正要通过加油站。在他面前是一条极宽的马路，当然马路的长度更是远长于宽，现在从 JZM 的位置算起，往前延申就有 1,000,000 km 左右的长度。马路上有 N 条(条?)加油站，每条加油站从距离 JZM $L_i$ 米处延伸到距离 JZM $R_i$ 米处。JZM 可以从一条加油站的开头 ( $L_i$ 处) 进入，然后从结尾 ( $R_i$ 处) 出加油站，然后可以横向走，到其它加油站的开头，但是不能逆行，也就是说，他的下一个加油站的 $L$ 必须大于等于上一个加油站的 $R$ 。

JZM 必须通过 K 条加油站，才能加满油，因此，他想知道一种通过加油站的方案。如果有多个通过加油站的方案，JZM 想知道字典序最小的加油方案。具体地说，如果有两种方案，把通过的加油站编号从小到大排序后形成的数组分别为 A 和 B（长度当然都为 K），那么 A 和 B 中字典序更小的数组代表的方案将优先考虑。由于加油站对电子设备有些限制，所以 JZM 把这个问题抛给了你。

注意：由于马路很宽，因此不同的加油站可以并排存在，也就是说它们的可能存在 $L_i\leq L_j\leq R_i\leq R_j$ 或者 $L_i\leq L_j <R_j\leq R_i$ 的情况。

$1 \leq N \leq 100000 .$
$1 \leq K \leq N .$
$1 ≤ L_i < R_i ≤ 1,000,000,000\;(1 ≤ i ≤ N).$

输入

$N\;\;K$
$L_i\;\;R_i$
$. . .$
$L_N\;\;R_N$

输出

K 行，第 i 行为你的字典序最小的方案中从小到大第 i 个编号。若无法通过不小于 K 条加油站，则输出 -1.

样例

Sample Input 1

Sample Output 1

Sample Input 2

20 16
250732298 258217736
26470443 34965880
252620676 260043105
692063405 697656580
497457675 504191511
391372149 397942668
858168758 867389085
235756850 241022021
585764751 593366541
207824318 217052204
661682908 671226688
886273261 892279963
770109416 778960597
264372562 270395107
176883483 186662376
509929119 519063796
109491630 118520141
162731982 168101507
662727316 668317158
757072772 765493222

Sample Output 2

题解

我们可以找到一种宏观的思路：编号从 1 开始枚举加油站，如果选了该加油站后整个方案的最大加油站数量仍然不小于 K ，就一定把该加油站选上，然后再考虑下一个加油站。

这个过程可以这样维护：新加入一个加油站有个前提，即这个加油站不会跟先前已选的加油站交叉或包含，这个随便用个树状数组维护就行了。新加入一个加油站后会把一段区间切成两半，这两半是互不干涉的了，因此我们把原先这段区间的答案减去，再加上切半后的左半边区间答案+右半边区间答案+1就是选了这个区间后最大加油站数量。

因此这道题的核心就是快速求任意一段区间内（隔绝）单独考虑方案的最大不相交加油站数量。

$\rm N^2$

我们把加油站按照右端点放到数轴上（已离散化），于是每次求一个区间 $[l, r]$ 的答案时，就可以从左端点开始做一个 DP。 $d p [i]$ 表示右端点小于等于 $i$ 的最大不相交数量，那么：

$dp[i]=\max(dp[i-1],\max_{R_j=i,L_j\geq l}dp[L_j]+1)$

这样一来算一个区间就是 $O (N)$ 的了，总复杂度 $O(N^2)$ 。

$\rm N\sqrt N$

我们可以反着考虑，某个点开始往前通过 X 个加油站后的最近距离。如果我们提前把每个点往前通过 $1$ ~ ${\sqrt N}$ 个加油站的最近距离都处理出来，然后算区间 $[l, r]$ 时就直接枚举，这不就能做到 $O(N\sqrt N)$ 了吗？

$\rm N\log N$

其实根本没必要想根号的做法，我们直接存每个点开始往前通过 $2^x$ 个加油站后的最近距离，然后算区间 $[l, r]$ 时直接倍增不就完了？

CODE

#include<set>
#include<map>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 100005
#define DB double
#define LL long long
#define ENDL putchar('\n')
#define lowbit(x) (-(x) & (x))
#define eps 1e-9
#define FR first
#define SE second
#define SI set<pair<int,int> >::iterator 
#define makepair(x,y) (pair<int,int>){(x),(y)}
LL read() {
	LL f = 1,x = 0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f * x;
}
const int MOD = 1000000007;
int n,m,i,j,s,o,k;
int ll[MAXN],rr[MAXN];
int b[MAXN<<1],cnb,NM;
vector<int> pr[MAXN<<1],pl[MAXN<<1];
map<int,int> mp;
int dp[MAXN<<1];
bool cmpid(int a,int b) {return dp[a] > dp[b];}
int rmq[MAXN<<1][21];// 18
int cont(int l,int r) {
	int as = 0,ad = r;
	for(int i = 18;i >= 0;i --) {
		if(rmq[ad][i] >= l) {
			as += (1<<i);
			ad = rmq[ad][i];
		}
	}
	return as;
}
int c[MAXN<<1];
void addt(int x,int y) {while(x<=NM)c[x]+=y,x+=lowbit(x);}
int sum(int x) {int as=0;while(x>0)as+=c[x],x-=lowbit(x);return as;}
set<pair<int,int> > st;
int as[MAXN];
int c2[MAXN];
int id[MAXN];
void addc(int x,int y) {while(x>0)c2[x] = min(c2[x],y),x -= lowbit(x);}
int minc(int x) {
	int as = 0x7f7f7f7f;
	while(x<=NM)as = min(as,c2[x]),x += lowbit(x);
	return as;
}
int main() {
	n = read();k = read();
	for(int i = 1;i <= n;i ++) {
		s = ll[i] = read();
		o = rr[i] = read();
		b[++ cnb] = s;
		b[++ cnb] = o;
	}
	sort(b + 1,b + 1 + cnb);
	for(int i = 1;i <= cnb;i ++) {
		if(i==1 || b[i] > b[i-1]) {
			mp[b[i]] = ++ NM;
		}
	}
	for(int i = 1;i <= n;i ++) {
		ll[i] = mp[ll[i]];rr[i] = mp[rr[i]];
		pr[rr[i]].push_back(i);
		pl[ll[i]].push_back(i);
	}
	for(int j = 0;j <= 18;j ++) rmq[0][j] = -1;
	for(int i = 1;i <= NM;i ++) {
		for(int j = 0;j <= 18;j ++) rmq[i][j] = -1;
		for(int j = 0;j < (int)pr[i].size();j ++) {
			int y = pr[i][j];
			rmq[i][0] = max(rmq[i][0],ll[y]);
		}
		rmq[i][0] = max(rmq[i][0],rmq[i-1][0]);
		for(int j = 1;j <= 18;j ++) {
			if(rmq[i][j-1] < 0) break;
			rmq[i][j] = rmq[rmq[i][j-1]][j-1];
		}
	}
	int sm = 0;
	st.insert(makepair(1,sm = cont(1,NM)));
	st.insert(makepair(NM,0));
	int cn = 0;
	for(int i = 1;i <= n;i ++) {
		if(cn >= k) break;
		if(!(sum(rr[i])-sum(ll[i]))) {
			SI t = st.upper_bound(makepair(ll[i],0x7f7f7f7f));
			int ri = t->FR;
			t --;
			int sm2 = sm - t->SE,li = t->FR;
			int cl = cont(li,ll[i]),cr = cont(rr[i],ri);
			if(sm2 + cl + cr + 1 >= k) {
				st.erase(*t);
				st.insert(makepair(li,cl));
				st.insert(makepair(ll[i],1));
				st.insert(makepair(rr[i],cr));
				sm = sm2+cl+cr+1;
				as[++ cn] = i;
				for(int j = ll[i]+1;j <= rr[i];j ++) addt(j,1);
			}
		}
	}
	if(cn < k) printf("-1\n");
	else for(int i = 1;i <= k;i ++) {
		printf("%d\n",as[i]);
	}
	return 0;
}