【专题复习】树状数组

前言

一天一个专题，还行。

一直都有keep住树状数组的正确姿势，这次也主要是练习了一些变式题目，一些处理比记住板子更加重要，只要知道这东西的问法和用途往上套才行。

之前在ybtoj上面有写过六道模板题，比今天的题目更难，可以回去看看，特别是带有区间修改的。

对于树状数组在区间中的用途，最经典的就是区间加减和差和逆序对，有时候需要将问题转化，得到模型，后面的题目中会具体展现。最基础直白的模板就不放了。

例题

1. poj2481 Cows

分析

题意就是求一个区间被几个区间“覆盖”（完全重叠不算）。

一开始想开两个树状数组的，但是没办法实现题目的操作。所以就对区间头升序排列，区间头相等的区间尾降序排列。然后实时加入树状数组，因为这样的排序，所以能覆盖他的都在他前面，统计前面有多少个区间尾比他大的，就是覆盖的。注意相等的情况，个数跟前面那个一样就行。

上代码

#include
#include
#include
#include
using namespace std;

struct node
{
	int x,y,p;
}a[100010];

int n,c[100010],ans[100010],mx;

int cmp(node l,node r)
{
	if(l.x==r.x) return l.y>r.y;
	else return l.x<r.x;
}
int cmp2(node l,node r)
{return l.p<r.p;}

int lowbit(int x){return x&(-x);}
int change(int x,int v)
{for(int i=x;i<=mx;i+=lowbit(i)) c[i]+=v;}
int getsum(int x)
{
	int s=0;
	for(int i=x;i;i-=lowbit(i)) s+=c[i];
    return s;
}

int main()
{
	scanf("%d",&n);
	while(n!=0)
	{
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d",&a[i].x,&a[i].y);
			a[i].x++;a[i].y++;
			a[i].p=i;
			mx=max(mx,a[i].y);
		}
		sort(a+1,a+n+1,cmp);
		for(int i=1;i<=n;i++)
		{
			if(i!=1&&a[i].x==a[i-1].x&&a[i].y==a[i-1].y)
			{
				ans[a[i].p]=ans[a[i-1].p];
			} 
			else ans[a[i].p]=getsum(mx)-getsum(a[i].y-1);
			change(a[i].y,1);
		}
		sort(a+1,a+n+1,cmp2);
		for(int i=1;i<=n-1;i++) printf("%d ",ans[i]);
		cout<<ans[n]<<endl;
		scanf("%d",&n);
		memset(c,0,sizeof(c));
		memset(ans,0,sizeof(ans));
		mx=0;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

2. poj3067 Japan

分析

手动模拟一下样例，很容易发现这是一道跟逆序对有关的题目。

我们将西海岸的城市作为数组的下标，东海岸的城市作为数组值，统计每个数加进来对逆序对的贡献。

具体实现就需要对西海岸城市升序排列，确保加进来的数数组下标不减。然后判断有多少个数 “比他先进来还比他大”。

最后吐槽一下poj，居然不给用“%lld”，人家CSP可是只能用这个的啊。。

上代码

#include
#include
#include
#include
using namespace std;
typedef long long ll;

struct node
{
	int x,y;
}a[1000100];

int t,n,m,k;
int c[1000100];
ll ans;

int cmp(node l,node r)
{
	if(l.y==r.y) return l.x<r.x;
	else return l.y<r.y;
}

int lowbit(int x){return x&(-x);}
void change(int x,int v)
{for(int i=x;i<=n;i+=lowbit(i)) c[i]+=v;}
ll getsum(int x)
{
	ll s=0;
	for(int i=x;i;i-=lowbit(i)) s+=c[i];
    return s;
}

int main()
{
	scanf("%d",&t);
	for(int i=1;i<=t;i++)
	{
		memset(c,0,sizeof(c));
		ans=0;
		scanf("%d%d%d",&n,&m,&k);
		/*西海岸作为下标，东海岸作为值*/
		for(int j=1;j<=k;j++)
		{
			scanf("%d%d",&a[j].x,&a[j].y);
		}
		sort(a+1,a+k+1,cmp);
		for(int j=1;j<=k;j++)
		{
			change(a[j].x,1);
			ans+=j-getsum(a[j].x);//逆序对 
		}
		printf("Test case %d: %I64d\n",i,ans);//poj这个才能过 
		//printf("Test case %d: %lld\n",i,ans);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

3. poj2155 矩阵

分析

发现这道题是取反，而不是累加，所以简单的矩阵加矩阵求和套进去是不可行的。

但是为什么他是矩阵取反单点求和呢，感觉有点奇怪是不是。

考虑取反运算的性质，取反偶数次是0，奇数次是1。

首先考虑一维的情况，我要一段区间取反，假设是 [l, r]。那么我只需要c[l]+1，c[r+1]+1，假设查询 k 的时候，只需要查询前 k 的和 mod 2 的结果即可。

然后我们用容斥轻松拓展到二维。

这里红色的就是上面需要标记的点，标记后表示以这个点为右下角的子矩阵内的点全部取反一次。这里绿色代表取反一次，紫色是取反了两次，黄色是取反了四次。最后实际进行取反操作的就是要求取反的子矩阵内的点。(本段转载，侵删)

最后这个问题变成了单点修改，区间查询的二维树状数组。

上代码

再次吐槽poj奇奇怪怪的输入输出。

#include
#include
#include
#include
using namespace std;

int t;
int n,m;
int c[1010][1010];

int lowbit(int x){return x&(-x);}
void update(int x,int y,int k)
{
	for(int i=x;i<=n;i+=lowbit(i))
	{
		for(int j=y;j<=n;j+=lowbit(j))
		{
			c[i][j]+=k;
		}
	}
}
long long getsum(int x,int y)
{
	long long s=0;
	for(int i=x;i;i-=lowbit(i))
	{
		for(int j=y;j;j-=lowbit(j))
		{
			s+=c[i][j];
		}
	}
	return s;
}

int main()
{
	cin>>t;
	while(t--)
	{
		scanf("%d%d",&n,&m);
		for(int i=1;i<=m;i++)
		{
			char op;
			cin>>op;
		    if(op=='Q')
		    {
		    	int x,y;
		    	scanf("%d%d",&x,&y);
		    	cout<<getsum(x,y)<<endl;
		    	printf("%d\n",getsum(x,y)%2);
			}
			else
			{
				int x1,y1,x2,y2;
				scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
				update(x1,y1,1);
				update(x1,y2+1,1);
				update(x2+1,y1,1);
				update(x2+1,y2+1,1);
			}
		}
		printf("\n");
		memset(c,0,sizeof(c));
	}
	return 0;
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

写在后面

希望CSP的时候我能用上这个好东西。