树状数组，离散化，突破口（Segment Game，HDU 5372）

树状数组讲解：

http://blog.csdn.net/int64ago/article/details/7429868

经常会遇到一些题目，是一些经典问题的变化，但是各种经典算法无法很好的解决这个问题。

这时我们应该观察题目是不是有特殊的地方，我们的经典算法是否只能解决更一般的问题。

特殊和一般在哪些地方有差别，哪些地方条件放宽了，哪些地方要求高了。

然后从这些差别入手，或许就可以发现本题独特的地方，从而有针对性地创造出一个解法。

离散化不一定要用map或者hash。

因为离散化往往都是离线的，所以离散的值一开始肯定是保存在数组中的，在使用这个值的时候一定知道它的下标，我们可以预处理一个下标映射表，然后利用这个值对应的下标直接找到映射的位置。建立下标映射表的时间复杂度为O（nlogn）。但建立完成后的使用则是O（1）的。

map是O（nlogn）建立，O（nlogn）使用，常数很大。

hash是O（maxn）初始化，O（n）建立，O（1）使用。

maxn可以动态赋值，时间复杂度应该很好，只不过maxn的取值如果不恰当那就可能会产生大量哈希冲突（在值普遍和maxn有倍数关系的情况下）。本题应该不会有问题。

第i个add操作，而不是第i个操作。因为这个TLE了好久。（当删除的第i个操作是也是一个删除操作时，我们有可能会得到pos=0，或者pos=以前的一些数据，当pos=0时，add函数会进入死循环）

细节决定成败。

代码

#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn = 200010;

int n;
int a[maxn],b[maxn],c[maxn];
int tp[maxn<<1];
int k;
int id[maxn][2];
int tag[maxn];

void read()
{
    int len=1;
    k=0;
    for(int i=1;i<=n;i++)
    {
        scanf("%d %d",a+i,b+i);
        if(a[i]==0)
        {
            c[i]=b[i]+len;
            tag[len++]=i;
            tp[k++]=b[i];
            tp[k++]=c[i];
        }
    }
    tp[k++]=1e9;
    tp[k++]=-1e9;
    sort(tp,tp+k);
    k=unique(tp,tp+k)-tp;
    for(int i=1;i<=n;i++) if(a[i]==0)
    {
        id[i][0]=upper_bound(tp,tp+k,b[i])-tp;
        id[i][1]=upper_bound(tp,tp+k,c[i])-tp;
    }
}

int tree[maxn<<1][2];

void build(int n)
{
    for(int i=1;i<=n;i++)
        tree[i][0]=tree[i][1]=0;
}

int low_bit(int x)
{
    return  x&(-x);
}

void add(int pos,int n,int val,int f)
{
    while(pos<=n)
    {
        tree[pos][f]+=val;
        pos+=low_bit(pos);
    }
}

int qry(int pos,int f)
{
    int ret=0;
    while(pos)
    {
        ret+=tree[pos][f];
        pos-=low_bit(pos);
    }
    return ret;
}

void solve()
{
    read();
    build(k);
    for(int i=1;i<=n;i++)
    {
        if(a[i]==0)
        {
            printf("%d\n",qry(id[i][1],1)-qry(id[i][0]-1,0));
            add(id[i][0],k,1,0);
            add(id[i][1],k,1,1);
        }
        else
        {
            add(id[tag[b[i]]][0],k,-1,0);
            add(id[tag[b[i]]][1],k,-1,1);
        }
    }
}

int main()
{
    int kase=0;
    while(~scanf("%d",&n))
    {
        printf("Case #%d:\n",++kase);
        solve();
    }
    return 0;
}