POJ——2481

●Poj 2481
●给你 n 个闭区间，问每一个区间被多少个区间完全包含（完全重合不算）。
●n<=100000
●Time Limit : 1s

●Memory Limit : 256MB

这应该算是一类套路题。对于区间覆盖型问题，普及难度的是贪心，再难一点点就是dp，提高难度的算是数据结构维护一下，如果是dp+数据结构，蒟蒻觉得应该要上省选了= =

这里还是一个树状数组搞一搞的问题。

对于一个区间，如果我们固定左端点，那么能覆盖它的只有右端点比它大的区间了，对不对。那么我们如果按左端点从小到大处理，用树状数组维护一下右端点的后缀和就可以了。但实际操作中，这么做是比较麻烦的（我没试过），所以我们再考虑反过来处理，将右端点从大到小排序，然后维护一下左端点的前缀和。

参考代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN=100010;
int c[MAXN];
struct Node
{
    int S,E;
    int index;
}node[MAXN];


int n;
int cnt[MAXN];//记录结果

//先按照E从大到小排序，E相同则按照S从小到大排序
bool cmp(Node a,Node b)
{
    if(a.E==b.E)return a.S<b.S;
    return a.E>b.E;
}
int lowbit(int x)
{
    return x&(-x);
}
void add(int i,int val)
{
    while(i<=n)
    {
        c[i]+=val;
        i+=lowbit(i);
    }
}
int sum(int i)
{
    int s=0;
    while(i>0)
    {
        s+=c[i];
        i-=lowbit(i);
    }
    return s;
}
int main()
{
    while(scanf("%d",&n),n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&node[i].S,&node[i].E);
            node[i].index=i;
        }
        sort(node+1,node+n+1,cmp);
        memset(c,0,sizeof(c));
        memset(cnt,0,sizeof(cnt));
        cnt[node[1].index]=0;
        add(node[1].S+1,1);
        for(int i=2;i<=n;i++)
        {
            if(node[i].E==node[i-1].E&&node[i].S==node[i-1].S)
               cnt[node[i].index]=cnt[node[i-1].index];
            else
                cnt[node[i].index]=sum(node[i].S+1);
            add(node[i].S+1,1);
        }
        printf("%d",cnt[1]);
        for(int i=2;i<=n;i++)
          printf(" %d",cnt[i]);
        printf("\n");
    }
    return 0;
}