树状数组不用多讲了，网上有关于这方面的内容很多，找找都是一大片，而且也不是很难，去学一下就可以很快领悟，至于怎么用，这就需要大量的做题了！
先提个注意点，由于Lowbit(0) = 0，这会导致x递增的那条路径发生死循环，所有当树状数组中可能出现0时，我们都全部加一，这样可以避免0带来的麻烦～～
简单：
POJ 2299 Ultra-QuickSort
http://acm.pku.edu.cn/JudgeOnline/problem?id=2299
求逆序数，可以用经典的归并排序做，也是基本的树状数组题目。
因为a[i]比较大，但只有最多500000个，所以要离散化。
逆序数就是求前面的数比后面的数大的次数。从后往前看就是求后面比前小的数的个数。用树状数组！c[i]表示比i的值小的个数。
代码
#include <iostream>
#include <algorithm>
using namespace std;
int n;
struct node
{
int num;
int set;
}a[500005];
int hash[500005];
__int64 c[500005];
int cmp(node b,node c)
{
return c.num > b.num;
}
int Lowbit(int t)
{
return (-t) & t;
}
__int64 Sum(int end)
{
__int64 sum = 0;
while(end>0)
{
sum += c[end];
end -= Lowbit(end);
}
return sum;
}
void Modity(int pos,int add)
{
while(pos <= n)
{
c[pos] += add;
pos += Lowbit(pos);
}
}
int main()
{
int i;
while(scanf("%d",&n)!=EOF && (n != 0))
{
for(i=0;i<=n;i++)
c[i] = 0;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i].num);
a[i].set = i;
}
sort(a+1,a+1+n,cmp);
for(i=1;i<=n;i++)
{
hash[a[i].set] = i;
}
__int64 sum = 0;
for(i=n;i>=1;i--)
{
sum += Sum(hash[i]);
Modity(hash[i],1);
}
printf("%I64d\n",sum);
}
return 0;
}
POJ 2352 Stars
http://acm.pku.edu.cn/JudgeOnline/problem?id=2352
题目意思就是求每个星星左下方的星星的个数，由于y轴已经排序好了，我们可以直接用按x轴建立一维树状数组，然后求相当于它前面比它小的个数，模板直接一套就搞定了～～
POJ 1195 Mobile phones
http://acm.pku.edu.cn/JudgeOnline/problem?id=1195
二维的树状数组，直接把Update()和Getsum()改为二维即可。
如Update()函数改为：
void Update(int x, int y, int d)
{ // 注意：当i = 0，0 + Lowbit(0) = 0，会造成死循环!
int i, j;
for (i = x; i < maxn; i += Lowbit(i)) // 注意这里是maxn，是tree[]的大小.
{
for (j = y; j < maxn; j += Lowbit(j))
{
tree[i][j] += d;
}
}
}
写这题的好时候就是求区间和时应该是（x2,y2）-(x2,y1-1)-(x1-1,y2)+(x1,y1)。而不是（x2,y2）-(x2,y1)-(x1,y2)+(x1,y1).
POJ 2481 Cows
http://acm.pku.edu.cn/JudgeOnline/problem?id=2481
将E从打到小排序，如果E相等按S排序，然后就跟POJ 2352 Stars做法一样了～～
POJ 3067 Japan
http://acm.pku.edu.cn/JudgeOnline/problem?id=3067
先按第一个坐标排序从大到小排序，如果相等按第二个坐标从大到小排序，然后就又是跟Cows和Stars做法相同了...
做的时候有两点注意：1，算逆序的时候相同的不应该算，即求和时应该减一。
2，要用__int64
POJ 2029 Get Many Persimmon Trees
http://acm.pku.edu.cn/JudgeOnline/problem?id=2029
O(n ^ 2)枚举起点，再用二维树状数组求其中的点数即可。
中等：
POJ 2155 Matrix
http://acm.pku.edu.cn/JudgeOnline/problem?id=2155
经典树状数组题目，分析见前一篇文章（树状数组学习系列1 之 初步分析——czyuan原创）～～
POJ 3321 Apple Tree
http://acm.pku.edu.cn/JudgeOnline/problem?id=3321
这题的难点不在于树状数组，而是如果将整棵树映射到数组中。我们可以用DFS()改时间戳的方法，用begin[i]表示以i为根的子树遍历的第一个点，end[i]表示以i为根的子树遍历的最后一个点。
比如数据为：
5
1 2
2 5
2 4
1 3
那么begin[] = {1, 2, 5, 4, 3}, end[] = {5, 4, 5, 4, 3}，下标从1开始。
对于每个点都对应一个区间(begin[i], end[i])，如果要改变点a的状态，只要Update(begin[a])，要求该子树的苹果树，即Getsum(begin[a] ) - Getsum(end[a] + 1)，(注：这里求和是求x递增的路径的和。)
POJ 1990 MooFest
http://acm.pku.edu.cn/JudgeOnline/problem?id=1990
这题的难点是要用两个一维的树状数组，分别记录在它前面横坐标比它小的牛的个数，和在它前面横坐标比它小的牛的横坐标之和。
按音量排个序，那么式子为：
ans += 1LL * cow[i].volumn * (count * x - pre + total - pre - (i - count) * x);
cow[i].volumn为该牛的能够听到的音量。
count为在第i只牛前面横坐标比它小的牛的个数。
pre为在第i只牛前面横坐标比它小的牛的横坐标之和。
total 表示前i - 1个点的x坐标之和。
分为横坐标比它小和横坐标比它大的两部分计算即可。
Hdu 3015 Disharmony Trees
http://acm.hdu.edu.cn/showproblem.php?pid=3015
跟上题方法相同，只要按它的要求离散化后，按高度降序排序，套用上题二个树状数组的方法即可。
Hdu 2852 KiKi's K-Number
http://acm.hdu.edu.cn/showproblem.php?pid=2852
这题与上面那题类似，只是要求比a大的第k大的数，那我们用Getsum(a)求出小于等于a的个数，那么就是要我们求第k + Getsum(a)大的数，而删除操作只要判断Getsum(a) – Getsum(a - 1)是否为0，为0则说明a不存在。
难题：
POJ 2464 Brownie Points II
http://acm.pku.edu.cn/JudgeOnline/problem?id=2464
这道题用二分也可以做的，这里介绍下树状数组的做法。首先有n个点，过每个点可以做x,y轴，把平面切成BL, TL, TR, BR四个部分，我们现在的问题是如果快速的计算这四个部分的点的个数。
这样我们可以先预处理，先按y坐标排序，求出每个点正左方和正右方的点的个数LeftPoint[], RightPoint[]，复杂度为O(n)，同样我们再以x坐标排序，求出每个点正上方和正下方点的个数UpPoint[], DownPoint[]。还要求出比点i y坐标大的点的个数 LageY[]。注意：这里要进行下标映射，因为两次排序点的下标是不相同的。
然后按x坐标从小到大排序，x坐标相等则y坐标从小到大排序。我们可以把y坐标放在一个树状数组中。
对于第i个点，求出Getsum(y[i])即为BL的个数，然后Update(y[i])。由于现在是第i点，说明前面有i – 1个点， 那么
TL = i - 1 - LeftPoint[i]- BL;
TR = LargeY[i] - TL – UpPoint[i] ;
BR = n - BL - TL - TR - LeftPoint[i] - RightPont[i] - UpPoint[i] – DownPont[i] - 1;
这样我们就求出四个部分的点的个数，然后判断有没有当前解优，有的话就更新即可～～
代码
#include <iostream>
#include <algorithm>
using namespace std;
#define maxn 200005
struct node
{
int x;
int y;
int LeftPoint; //正左边的点数
int RightPoint; //正右边的点数
int UpPoint; //正上方的点数
int DownPoint; //正下方的点数
int LargeY; //比该点Y大的数的数目
}p[maxn];
int C[maxn];
int BL,TL,TR,BR;
/*对第j个点的四块内的点数
BL = Getsum(p[j].y) - p[j].LeftPoint - p[j].DownPoint;
TL = j - p[j].LeftPoint - p[j].DownPoint - BL;
TR = p[j].LargeY - TL - p[j].UpPoint;
BR = n - j - 1 - TR - p[j].RightPoint - p[j].UpPoint;
*/
struct node1
{
int Stan;
int Ollie;
}V[maxn];
bool cmp(node a,node b)
{
if(a.x == b.x)
return a.y < b.y;
return a.x < b.x;
}
bool cmp2(node a,node b)
{
if(a.y == b.y)
return a.x < b.x;
return a.y < b.y;
}
bool cmp3(node1 a,node1 b)
{
if(a.Stan == b.Stan)
return a.Ollie < b.Ollie;
return a.Stan > b.Stan;
}
//bool cmp1(node a,node b){return a.x < b.x;}
int lowb(int t)
{
return t&(-t);
}
void Updata(int i)
{
while(i<maxn)
{
C[i] += 1;
i += lowb(i);
}
}
int Getsum(int i)
{
int s = 0;
while(i>0)
{
s += C[i];
i -= lowb(i);
}
return s;
}
int main()
{
int i,j,k;
int n,num;
while(scanf("%d",&n)!=EOF && n!=0)
{
memset(C,0,sizeof(C));
for(i=0;i<n;i++)
{
scanf("%d%d",&p[i].x,&p[i].y);
}
sort(p,p+n,cmp); //X轴离散化
for(num=1,i=0;i<n;num++)
{
for(j=i+1;j<n;j++)
{
if(p[i].x != p[j].x)
break;
}
for(k=i;k<j;k++)
{
p[k].UpPoint = j-1-k;
p[k].DownPoint = k - i;
p[k].x = num;
}
i = j;
}
sort(p,p+n,cmp2);//Y轴离散化
for(num=1,i=0;i<n;num++)
{
for(j=i+1;j<n;j++)
{
if(p[i].y != p[j].y)
break;
}
for(k=i;k<j;k++)
{
p[k].LeftPoint = k - i;
p[k].RightPoint = j-1-k;
p[k].y = num;
p[k].LargeY = n - j;
}
i = j;
}
sort(p,p+n,cmp);
for(num=0,i=0;i<n;num++)
{
int Stan_num = 0x7fffffff;
int Ollie_num = 0;
for(j=i;j<n;j++)
{
if(p[j].x != p[i].x)
break;
BL = Getsum(p[j].y) - p[j].LeftPoint - p[j].DownPoint;
TL = j - p[j].LeftPoint - p[j].DownPoint - BL;
TR = p[j].LargeY - TL - p[j].UpPoint;
BR = n - j - 1 - TR - p[j].RightPoint - p[j].UpPoint;
if(TL + BR > Ollie_num)
{
Stan_num = BL + TR;
Ollie_num = TL + BR;
}
else if(TL + BR == Ollie_num)
{
if(BL + TR <= Stan_num)
{
Stan_num = BL + TR;
}
}
Updata(p[j].y);
}
V[num].Ollie = Ollie_num;
V[num].Stan = Stan_num;
i = j;
}
sort(V,V+num,cmp3);
printf("Stan: %d; Ollie:",V[0].Stan);
for(i=0;i<num;i++)
{
if(V[i].Stan != V[0].Stan)
break;
if(V[i].Ollie == V[i-1].Ollie && i != 0)
continue;
printf(" %d",V[i].Ollie);
}
printf(";\n");
}
//system("pause");
return 0;
}