树状数组入门

树状数组讲解：https://blog.csdn.net/bestsort/article/details/80796531

1.敌兵布阵(模板题)

http://acm.hdu.edu.cn/showproblem.php?pid=1166

树状数组（模板）代码：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=1e6+10;
int c[maxn];

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

void update(int x,int y,int n)
{
    for(int i=x;i<=n;i+=lowbits(i))
    {
        c[i]+=y;
    }
}

int getsum(int x)
{
    int sum=0;
    for(int i=x;i;i-=lowbits(i))
    {
        sum+=c[i];
    }
    return sum;
}

int main()
{
    int t,k=0;
    scanf("%d",&t);
    while(t--)
    {
        k++;
        memset(c,0,sizeof(c));
        int n;
        scanf("%d",&n);
        int y;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&y);
            update(i,y,n);
        }
        char s[10];int a,b;
        printf("Case %d:\n",k);
        while(1)
        {
            scanf("%s",s);
            if(s[0]=='E')
                break;
            scanf("%d%d",&a,&b);
            if(s[0]=='Q')
            {
                int ans=getsum(b)-getsum(a-1);
                printf("%d\n",ans);
            }
            else if(s[0]=='A')//注意这里是else if,不能写if,粗心被卡了
            {
                update(a,b,n);
            }
            else
                update(a,-b,n);
        }

    }
    return 0;
}

2.Stars

http://poj.org/problem?id=2352

题意：定义星星的等级为在它左下角（包括正左和正下）的星星的个数。给出若干个星星的坐标（不超过15000个），输出各个等级的星星分别有多少个。每个星星的坐标不超过32000，输入时按照Y坐标升序输入。

分析：

固定一个维度，剩下的就是看剩下的那一个维度了。

因为题目已经按照Y坐标升序排列了，只需要每次读入时用树状数组统计X坐标比小于等于X的星星有多少个算出其等级再统计就可以了。不过，要注意坐标有可能为0，为0时会死循环，所以在读入坐标时应加1。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#define ll long long
using namespace std;
const int maxn=1e6+10;
int n,c[maxn],ans[maxn],level[maxn];
struct node
{
    int x;
    int y;
}star[maxn];
int lowbit(int x)
{
    return x&(-x);
}
int sum(int x)
{
    int ans=0;
    for(int i=x;i>0;i-=lowbit(i))
            ans+=c[i];
    return ans;
}
void add(int x)
{
    for(int i=x;i<=maxn;i+=lowbit(i))
    {
        c[i]+=1;
    }
}
int main()
{
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
           scanf("%d%d",&star[i].x,&star[i].y);
           star[i].x++;star[i].y++;//注意会有0的情a况！
        }
        int l;
        for(int i=1;i<=n;i++)
        {
            l=sum(star[i].x);//查找
            level[l]++;
            add(star[i].x);//添加
        }
        for(int i=0;i<n;i++)
        {
           printf("%d\n",level[i]);
        }
    return 0;
}

 

3.Cows

http://poj.org/problem?id=2481

题意：有n头牛，每头牛对应一个区间[Si，Ei]，如果牛j 的区间是牛i 的区间的真子集(即Si <= Sj and Ej <= Ei and Ei - Si > Ej - Sj)，那么就说牛i 比牛j 强壮。要你依次输出比第i头牛强壮的牛数目。

思路：如果将所有牛的E区间按从大到小排序(如果E相同,则S小的排在前面)的话，那当前读取到第i个牛的Si和Ei，那么之前(假设任意牛的区间不会完全相同)的牛的Sj(j<=i-1)<=Si的这些牛就都比i号牛强壮了。可以理解为之前那道star的题，固定一个维度，剩下的就是看剩下的那一个维度了。

分析：

固定一个维度，剩下的就是看剩下的那一个维度了。

1.这里有可能有两个区间一模一样的，防止重复叠加，需要特判 ,直接赋值!

2.Si会有0的情况！

3.重点是排序要排对!

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#define ll long long
using namespace std;
const int maxn=1e6+10;
int n,c[maxn],ans[maxn];
struct node
{
    int x;
    int y;
    int id;
}cow[maxn];
bool cmp(node a,node b)//通过排序来固定一个维度，剩下的就是看剩下的那一个维度了。
{
    if(a.y!=b.y)
        return a.y>b.y;
    return a.x<b.x;
}
int lowbit(int x)
{
    return x&(-x);
}
int sum(int x)
{
    int ans=0;
    for(int i=x;i>0;i-=lowbit(i))
            ans+=c[i];
    return ans;
}
void add(int x)
{
    for(int i=x;i<=maxn;i+=lowbit(i))
    {
        c[i]+=1;
    }
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        memset(c,0,sizeof(c));
        memset(ans,0,sizeof(ans));
        for(int i=1;i<=n;i++)
        {
           scanf("%d%d",&cow[i].x,&cow[i].y);
           cow[i].x++;cow[i].y++;//注意会有0的情况！
           cow[i].id=i;
        }
        sort(cow+1,cow+n+1,cmp);//注意细节
        ans[cow[1].id]=sum(cow[1].x);
        add(cow[1].x);
        for(int i=2;i<=n;i++)
        {
            if((cow[i].x==cow[i-1].x)&&(cow[i].y==cow[i-1].y))
                ans[cow[i].id]=ans[cow[i-1].id];
            //注意防止重复叠加，需要特判   
            else
                ans[cow[i].id]=sum(cow[i].x);//查找
            add(cow[i].x);//添加
        }
        for(int i=1;i<=n;i++)
        {
            printf("%d ",ans[i]);
        }
        printf("\n");
    }
    return 0;
}

3.Ultra-QuickSort

http://poj.org/problem?id=2299

树状数组求逆序对（模板）

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
struct node
{
	int val,jiaobiao;
}chu[500010];//最初的输入 
int a[500010];//离散化后的数组 
int c[500010];//树状数组 
bool cmp(struct node a,struct node b)
{
	return a.val<b.val;
}
void update(int x)
{
	while(x<=n)
	{
		c[x]=c[x]+1;//+1代表多了a[i]这么一个数 
		x=x+(x&(-x));
	}
}
int sum(int x)
{
	int s=0;
	while(x>=1)
	{
		s=s+c[x];
		x=x-(x&(-x));
	}
	return s;
}
int main()
{
	while(scanf("%d",&n)!=EOF)
	{
		if(n==0)
		break;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&chu[i].val);
			chu[i].jiaobiao=i;
		}
		sort(chu+1,chu+1+n,cmp);//排序后，值最小的排在最前面
		for(int i=1;i<=n;i++)//离散化 
		{
			a[chu[i].jiaobiao]=i;//排序后值最小的在前面，所以从前往后扫赋值i 
		}
		long long ans=0;//注意用long long 
		memset(c,0,sizeof(c));
		for(int i=1;i<=n;i++)
		{
			update(a[i]);//更新c[a[i]]及上层结构的c值
			ans=ans+i-sum(a[i]);//计算当前比a[i]小的数的个数 
		}
		printf("%lld\n",ans);
	}
	return 0;
}

参考讲解：https://blog.csdn.net/zugofn/article/details/52228568