题目
You are given a sequence
a1
,
a2
, …,
an
of one-dimensional segments numbered
1
through
Segment [ l1 , r1 ] lies within segment [ l2 , r2 ] iff l1 ≥ l2 and r1 ≤ r2 .
Print indices i and j. If there are multiple answers, print any of them. If no answer exists, print −1 −1 .
Input
The first line contains one integer
n
(
Each of the next n lines contains two integers li and ri (
1
≤
Output
Print two distinct indices
Examples
Input |
---|
5 1 10 2 9 3 9 2 3 2 9 |
Output |
2 1 |
Input |
---|
3 1 5 2 6 6 20 |
Output |
-1 -1 |
Note
In the first example the following pairs are considered correct:
- (2, 1), (3, 1), (4, 1), (5, 1) — not even touching borders;
- (3, 2), (4, 2), (3, 5), (4, 5) — touch one border;
- (5, 2), (2, 5) — match exactly.
分析
好吧,我想复杂了,拿到这道题的时候,我马上就想起了最近打过的教育场也有过一个数对匹配的问题 961E. Tufurama,其中提到了一种思想,按一定的顺序依次处理,使得处理过的数后面不会再用到,而可以直接删除,并利用树状数组来高效处理删除操作。
树状数组的讲解可以看这篇->树状数组总结
【思路】
首先,数对的个数总共3e5,但区间范围大到1e9,所以先把数据离散化一下。由于区间包含的关系,两边都是取≤,所以相同的数据还是得相同。
接下来得设计一个好的顺序,让后处理的区间只可能被先处理的区间包含,也就是说处理过的区间以后不可能再被包含,就可以直接删除掉。因此,把所有的区间按左端点从小到大排序,左端点相等的按右端点从大到小排序。
树状数组维护删除操作:由于是按左端点递增排序的,也就是说剩下的区间的左端点都比当前区间的左端点大,那么要寻找一个区间可以包含的子区间,只需要检查剩下的区间有没有右端点比他小的就行了。因此,树状数组维护的是右端点在1~x的区间的个数,由于离散化了开一个6e5的数组就能存下。假设当前区间是 ( li , ri ) ,只需要检查c[ ri ]是否>1,如果是,则一定有一个区间被它包含;而处理完以后,则从树状数组中删除 ri ,因为处理后面的区间的时候, ri 是没有用的。
【注意】
离散后的区间端点的范围是6e5
代码
#include<stdio.h>
#include<algorithm>
using std::sort;
#define N_max 300005
/*
* n个一维区间,从1~n编号
* 找到区间i 包含于区间 j
*/
//用于离散数据的结构体
struct Side
{
int val;
int disval;
int id;
}data[N_max<<1],*l,*r;
//记录离散后的区间的结构体
struct Rage
{
int l;
int r;
int id;
}rg[N_max];
//离散时的两种排序
int cmpv(Side s1, Side s2) {
return s1.val < s2.val;
}
int cmpi(Side s1, Side s2) {
return s1.id < s2.id;
}
//对离散后的区间按l排序
int cmpl(Rage r1, Rage r2) {
if (r1.l == r2.l)return r1.r > r2.r;
return r1.l < r2.l;
}
//BinaryIndexedTree
struct BIT {
int c[N_max<<1] = { 0 };//每个ci维护的都是1~i的最新和
int lowbit[N_max<<1] = { 0 };
int n;
BIT(int _n = (N_max<<1)) {
n = _n;
for (int i = 1; i <= (N_max<<1); ++i) lowbit[i] = (i&(-i));
}
void newBIT(int _n) {
n = _n;
for (int i = 1; i <= n; ++i)
c[i] = 0;
}
//更新时向右(上)更新
void update(int x, int num) {
while (x <= n) {
c[x] += num;
x += lowbit[x];
}
}
//求和时向左(下)依次求和
int getsum(int x) {
int s = 0;
while (x > 0) {
s += c[x];
x -= lowbit[x];
}
return s;
}
};
int n;
BIT cntr;
int main() {
scanf("%d", &n);
cntr.newBIT(2*n);
//把左端点存储在0~n-1,把右端点存储在n~2*n-1,并编号,方便离散化
//l和r是指针
l = data; r = data + n;
for (int i = 0; i < n; ++i)
{
l[i].id = i + 1; r[i].id = i + n + 1;
scanf("%d %d", &l[i].val, &r[i].val);
}
//离散化 li ri
//按数值排序
sort(data, data + n*2,cmpv);
for (int i = 0; i < n * 2; ++i)
{
//相同的还是得相同
if (i > 0 && data[i].val == data[i - 1].val)data[i].disval = data[i - 1].disval;
else data[i].disval = i + 1;
}
//还原为原来的顺序(id的顺序)
sort(data, data + n * 2, cmpi);
//将区间的信息整理到区间结构体中,并建立树状数组对ri个数的维护
for (int i = 0; i < n; ++i) {
rg[i].l = l[i].disval;
rg[i].r = r[i].disval;
rg[i].id = i + 1;
cntr.update(rg[i].r, 1);
}
//把区间按左端点递增,左端点相等时右端点递减的顺序排序
sort(rg, rg + n, cmpl);
//寻找被包含的区间
int flag = 0;
int temp;
for (int i = 0; i < n; ++i) {
temp = cntr.getsum(rg[i].r);
if ( temp> 1) {
flag = 1;
//因为要找到具体是哪一个被包含,所以遍历一下
for (int k = 0; k < n; ++k) {
//不能自己包含自己
if (k == i)continue;
if (rg[k].l >= rg[i].l&&rg[k].r <= rg[i].r)
{
printf("%d %d\n", rg[k].id, rg[i].id);
break;
}
}
break;
}
//没找到,在树状数组中删除r
else {
cntr.update(rg[i].r, -1);
}
}
if(flag==0)printf("-1 -1");
}
改进
这道题只需要找出一对有包含关系的区间就行了,但是我是完全以求所有包含关系的区间的总对数的方法来做的,所以代码量偏大。。。
其实这道题的核心就是分析里的这句话
那么要寻找一个区间可以包含的子区间,只需要检查剩下的区间有没有右端点比他小的就行了
既然已经按照左端点递增的顺序排列的,那么对于区间
i
(
总结
树状数组就是完美,不接受反驳