hdu 5372 Segment Game (树状数组+离散化）

参考：http://blog.csdn.net/queuelovestack/article/details/47446007

题意：给你n次操作，每次增加线段或者删除第i次增加操作中增加的线段，问你每次增加操作中，所增加的线段会覆盖多少条完整的线段。

题解：对于新插入的线段，查询有多少个线段左端点大于等于该线段的左端点。 再查询有多少个线段的右端点大于该线段右端点， 两者之差就是答案。用两个树状数组搞定。时间复杂度nlogn

之所以说只要查询左端点大于等于该线段的左端点的线段数-右端点大于该线段右端点的线段数即为答案，是因为一条线段[l0,r0]完全覆盖另一条线段[l1,r1]当且仅当l0<=l1&&r1<=r0，即左端点大于等于当前线段的左端点，右端点小于等于当前线段的右端点

解题思路：这题思路挺简单，用两个树状数组或者线段树进行单点更新(推荐树状数组，写起来相对方便一些)，然后求得区间内包含的线段即可，但有两个注意点：

     1.每次增加线段都比之前的所有线段长，所以求区间内线段数的时候不用考虑横穿整个区间，只需考虑全部在区间内或者部分在区间内，部分在区间外的线段；

     2.这里的删减操作是删除第i个增加操作的线段，增加操作也是增加一条长为当前第i个增加操作的长度是i，注意是增加操作，不是总的操作！

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <climits>
using namespace std;

const int INF=0x3f3f3f3f;
const int maxn=200010;
int a[maxn*2],b[maxn*2],l[maxn],r[maxn],d[maxn*2];
int x[maxn],y[maxn];

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

int sum(int x,int *c)
{
	int ret=0;
	while(x>0)
	{
		ret+=c[x];
		x-=lowbit(x);
	}
	return ret;
}

void add(int x,int *c,int num)
{
	while(x<=d[0])
	{
		if(num)
			c[x]++;
		else
			c[x]--;
		x+=lowbit(x);
	}
}

int main()
{
	int n,kase=1;
	while(~scanf("%d",&n))
	{
		memset(a,0,sizeof(a));
		memset(b,0,sizeof(b));
		int st=1;
		int num=1;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d",&x[i],&y[i]);
			if(!x[i])
			{
				d[st++]=y[i];
				d[st++]=y[i]+num;
				num++;
			}
		}
		sort(d+1,d+st+1);
		d[0]=unique(d+1,d+1+st)-(d+1);					//离散化
		printf("Case #%d:\n",kase++);
		int i,j;
		for(j=i=1;i<=n;i++)
		{
			if(x[i])
			{
				add(l[y[i]],a,0);
				add(r[y[i]],b,0);
			}
			else
			{
				l[j]=lower_bound(d+1,d+d[0]+1,y[i])-d;		//离散化:1,11,24,68,999 =>  1,2,3,4,5
				r[j]=lower_bound(d+1,d+d[0]+1,y[i]+j)-d;	
				//printf("%d\n",num-sum(l[j]-1,a)-(num-sum(r[j],b)));
				printf("%d\n",sum(r[j],b)-sum(l[j]-1,a));
				add(l[j],a,1);
				add(r[j],b,1);
				j++;
			}
		}
	}
	return 0;
}