题目链接

题目

题目描述

小石有 n 个妹子，每个妹子都有一个细心程度 \(a_i\)和一个热心程度 \(b_i\) ，
小石想给她们一个重要程度 \(t_i\)​（重要程度为 1 表示最重要，重要程度越小表示越重要）。
如果一个妹子 i 的细心程度和热心程度都比妹子 j 大，那么妹子 i 的重要程度要大于妹子 j 的重要程度，即妹子 i 比妹子 j 重要。
流程如下：
每次从所有没有重要程度的妹子中，找到若干妹子。对于这些妹子的任意一个，需要保证没有其他妹子比她更重要。然后把她们的重要程度标为 1 。下一次再从剩下没有重要程度的妹子中找到若干妹子，依然符合上述条件，然后把她们的重要程度标为 2，……，重复直到所有妹子都有自己的重要程度。
由于妹子太多，小石忙不过来，请你帮帮他。

输入描述

第一行输入一个正整数 n，表示妹子的数量。
接下来 n 行，每行两个正整数 \(a_i,b_i\) ，描述每个妹子的细心程度和热心程度。
保证所有的 \(a_i\) 两两不等，所有的 \(b_i\) 两两不等。

输出描述

共 n 行，第 i 行输出一个正整数 \(t_i\) 表示第 i 个妹子的重要程度。

示例1

输入

5
1 4
2 2
3 3
4 1
5 5

输出

2
3
2
2
1

说明

第一轮取第 5 个妹子（5 5），因为没有其他妹子比她重要，标记为 1；

第二轮取编号为 1，3，4 的妹子，因为对于其中的任意一个妹子，都没有其他妹子比她们重要，标记为 2；

第三轮把编号为 2 的妹子标记为 3 。

备注

\(1 \leq n \leq 10^5,1 \leq a_i,b_i \leq 10^9\)

题解

知识点：线段树，离散化。

某点的排名可以转化为属性 \(a,b\) 都严格比自己大的点的排名的最大值加 \(1\) 。显然，可以离线后按序输入，用权值线段树维护最大值即可。

需要注意的细节是，这道题要求二维属性都必须严格大于才构成一个偏序关系。因此，不妨按 \(a\) 从大到小排序，若 \(a\) 相同则按 \(b\) 从小到大排序，线段树维护属性 \(b\) 。

那么，对于当前输入进来的点 \((x,y)\) ，线段树已经维护了 \(a > x\) 的全部点，以及 \(a = x\) 且 \(b<y\) 的点。这样保证了询问 \(b>y\) 的区间时，能得到的只有 \(a>x\) 且 \(b>y\) 的点的最大值，而 \(a = x\) 且 \(b > y\) 的点不会纳入其中。

另外，因为坐标值域很大，所以需要用到离散化。

时间复杂度 \(O(n \log n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

template<class T>
struct Discretization {
    vector<T> uniq;
    Discretization() {}
    Discretization(const vector<T> &src) { init(src); }
    void init(const vector<T> &src) {
        uniq = src;
        sort(uniq.begin() + 1, uniq.end());
        uniq.erase(unique(uniq.begin() + 1, uniq.end()), uniq.end());
    }
    int get(T x) { return lower_bound(uniq.begin() + 1, uniq.end(), x) - uniq.begin(); }
};

struct T {
    int mx;
    static T e() { return { (int)0 }; }
    friend T operator+(const T &a, const T &b) { return { max(a.mx, b.mx) }; }
};
struct F {
    int mx;
    T operator()(const T &x) { return { max(x.mx,mx) }; }
};

template<class T, class F>
class SegmentTree {
    int n;
    vector<T> node;

    void update(int rt, int l, int r, int x, F f) {
        if (r < x || x < l) return;
        if (l == r) return node[rt] = f(node[rt]), void();
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, f);
        update(rt << 1 | 1, mid + 1, r, x, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }

    T query(int rt, int l, int r, int x, int y) {
        if (r < x || y < l) return T::e();
        if (x <= l && r <= y) return node[rt];
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }

public:
    SegmentTree(int _n = 0) { init(_n); }

    void init(int _n) {
        n = _n;
        node.assign(n << 2, T::e());
    }

    void update(int x, F f) { update(1, 1, n, x, f); }

    T query(int x, int y) { return query(1, 1, n, x, y); }
};

struct pk {
    int a, b;
    int id;
}p[100007];
int ans[100007];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    vector<int> b_src(n + 1);
    for (int i = 1;i <= n;i++) {
        int a, b;
        cin >> a >> b;
        p[i] = { a,b,i };
        b_src[i] = b;
    }

    Discretization<int> dc(b_src);
    sort(p + 1, p + n + 1, [&](const pk &a, const pk &b) { return a.a == b.a ? a.b < b.b : a.a > b.a; });

    int rk_n = dc.uniq.size() - 1;
    SegmentTree<T, F> sgt(rk_n);
    for (int i = 1;i <= n;i++) {
        int rk = dc.get(p[i].b);
        ans[p[i].id] = sgt.query(rk + 1, rk_n).mx + 1;
        sgt.update(rk, { ans[p[i].id] });
    }

    for (int i = 1;i <= n;i++) cout << ans[i] << '\n';
    return 0;
}