POJ 2481 Cows 树状数组

给你n个线段，让你求每个线段被几个线段覆盖。

我们要对线段（x，y）进行处理。

我们按照y从大到小排序，如果相等，那么x从小到大排序。

我们这样排序的话，我们首先是可以忽略y了，后面出现的线段y一定是小于等于前面的。

也就是说只看x小于前面的几个线段。

比如这组数据，4个线段。

3   5

2  4

1  3

2  3

2  6

首先排序

2    6

3   5

2   4

1   3

2   3

我们对于（2，6）

我们求2位置前面是否存在其他的点。不存在，也就是0. 之后我们让2位置=1.

我们对于（3，5）

之后我们看3位置前面是否存在其他的点。存在一个（前面设立的2位置那个点）。所以就是1 。之后我们让3位置=1 。  为什么存在呢。我们看的是当前线段是否被前面的线段覆盖。我们按y排的序，所以y一定是小于等于前面的了。如果对于x前面存在小于等于x的值，那么前面某个线段就完全覆盖当前线段了。也就是符合条件的。

以此类推即可。

不过我们需要处理离散化问题，我们这里就是如果排完序之后，枚举是，发现两个x相同，y也相同，我们就不用计算了。直接把上一个的值赋给这个即可，不要重新计算，这样会导致算出来的值多1.因为我们把自己（上一个，和自己一样嘛）也计算进去了。

#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()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    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;
}