codeforces 976 C Nested Segments（树状数组BIT复习）

题目

You are given a sequence $a_1$, $a_2$, …, $a_n$ of one-dimensional segments numbered $1$ through $n$. Your task is to find two distinct indices $i$ and $j$ such that segment $a_i$ lies within segment $a_j$.

Segment [$l_1$, $r_1$] lies within segment [$l_2$, $r_2$] iff $l_1$ ≥ $l_2$ and $r_1$ ≤ $r_2$.

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$ ($1$ ≤ $n$ ≤ $3·10^5$) — the number of segments.

Each of the next n lines contains two integers li and ri ($1$ ≤ $l_i$ ≤ $r_i$  ≤ $10^9$) — the $i$-th segment.

Output
Print two distinct indices $i$ and $j$ such that segment $a_i$ lies within segment $a_j$. If there are multiple answers, print any of them. If no answer exists, print $-1$ $-1$.

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的数组就能存下。假设当前区间是 ($l_i$, $r_i$) ，只需要检查c[$r_i$]是否>1，如果是，则一定有一个区间被它包含；而处理完以后，则从树状数组中删除$r_i$，因为处理后面的区间的时候，$r_i$是没有用的。

【注意】
离散后的区间端点的范围是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$ ($l_i$, $r_i$)只要在前面有一个$r_j$更大，它就一定被区间$j$包含。因此，维护一下从$0$ ~ $i$出现过的最大的$r_m$，如果$r_i$更小，那么$r_i$就是被包含的那个区间。

总结

树状数组就是完美，不接受反驳