Cows POJ

Cows

思路：我们可以按照每个范围的S从小到大排序，相同的S按E从大到小排序，这样的好处是当前范围的S一定大于等于之前范围的S（即当前的范围可能被之前范围的包围），那么我们只需要统计之前的范围E比当前的范围E大于等于的有几个即可。这里需要注意如果两个范围完全相同的情况，我们可以把当前的范围与之前的范围比较，如果相同，直接把之前的答案复制到当前就可。

#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>

#define lson (rt << 1)
#define rson ((rt << 1 | 1)
#define ll long long
#define pb push_back

using namespace std;

const int N = 1e5 + 10;
struct node{
    int number, l ,r;
    bool friend operator<(const node& a, const node & b){
        if(a.l != b.l) return a.l < b.l;
        else return a.r > b.r;
    }
}a;
vector<node > vn;
int tot[N], c[N], Max;
int n;

inline int lb(int x){
    return x&(-x);
}

void add(int x){
    for(int i = x; i <= Max; i += lb(i)) ++c[i];
}

int sum(int x){
    int sum = 0;
    for(int i = x; i >= 1; i -= lb(i)) sum += c[i];
    return sum;
}

void solve(){

    while(scanf("%d", &n) && n){
        vn.clear();
        Max = 0;
        for(int i = 1; i <= n; ++i){
            a.number = i;
            scanf("%d%d", &a.l, &a.r);
            ++a.l; ++a.r;
            Max = max(Max, a.r);
            vn.pb(a);
        }
        sort(vn.begin(), vn.end());
        for(int i = 1; i <= n; ++i) tot[i] = 0;
        for(int i = 1; i <= Max; ++i) c[i] = 0;
        int pre_l = -1, pre_r = -1, inx = -1;
        for(int i = 0; i != vn.size(); ++i){
            node it = vn[i];
            if(it.l == pre_l && it.r == pre_r){ //范围相同
                tot[it.number] = tot[inx];
                add(it.r);
            }
            else{
                pre_l = it.l; pre_r = it.r; inx = it.number; //改变前一个点
                if(it.r - 1 == 0) tot[it.number] = sum(Max);
                else tot[it.number] = sum(Max) - sum(it.r - 1);
                add(it.r);
            }
        }
        printf("%d", tot[1]);
        for(int i = 2; i <= n; ++i) printf(" %d", tot[i]);
        printf("
");
    }
}


int main(){



    solve();


    return 0;
}