Cows POJ - 2481 （树状数组 + 单点更新 + 区间查询）

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 + ;
 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 = ;
     for(int i = x; i >= ; i -= lb(i)) sum += c[i];
     return sum;
 }

 void solve(){

     while(scanf("%d", &n) && n){
         vn.clear();
         Max = ;
         for(int i = ; 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 = ; i <= n; ++i) tot[i] = ;
         for(int i = ; i <= Max; ++i) c[i] = ;
         int pre_l = -, pre_r = -, inx = -;
         for(int i = ; 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 -  == ) tot[it.number] = sum(Max);
                 else tot[it.number] = sum(Max) - sum(it.r - );
                 add(it.r);
             }
         }
         printf("%d", tot[]);
         for(int i = ; i <= n; ++i) printf(" %d", tot[i]);
         printf("\n");
     }
 }

 int main(){

     solve();

     return ;
 }