树状数组学习笔记

>>搞懂树状数组：http://blog.csdn.net/int64ago/article/details/7429868

据说可以用树状数组的解决的问题都可以用线段树解决，所以下面的题都是可以用线段树解决的。

一维树状数组应用：

我用到的模版表示：

#define MAXN 32005

int sum[MAXN];

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

void update(int x,int val)////如果要把a[i]增加v，可以通过调用如下函数实现
{
    while(x <= MAXN)
    {
        sum[x] += val;
        x += lowbit(x);//x+lowbit(x)可以理解变成了x的父亲
    }
}

int query(int x)//前x项和
{
    int s=0;
    while(x>0)
    {
        s += sum[x];
        x -= lowbit(x);//x-lowbit(x)可以理解成变成了x的兄弟
    }
    return s;
}

1，区间求和

poj-2352:

题意：一个“*”的层次是这样定义的，处于该“*”的下面和左面的范围内的“*”的个数即为该“*”的层次。题目要求处于0到n-1层次的“*”数目各有几个。

分析：由于“*”的坐标已经按Y递增的顺序排列好，对于具有相同Y坐标的“*”，又按其X坐标排序，故可充分利用这一输入特点，直接运用树状数组进行求解。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define MAXN 32005

int sum[MAXN],ans[MAXN];

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

void update(int x,int val)
{
    while(x <= MAXN)
    {
        sum[x] += val;
        x += lowbit(x);
    }
}

int query(int x)//前x项和
{
    int s=0;
    while(x>0)
    {
        s += sum[x];
        x -= lowbit(x);
    }
    return s;
}

int main()
{
    int n;
    while(scanf("%d",&n) != EOF)
    {
        int x,y;
        memset(sum,0,sizeof(sum));
        memset(ans,0,sizeof(ans));
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&x,&y);
            ans[query(x+1)]++;//x+1避免死循环,每次插入前查询小于x的和，
            update(x+1,1);
        }
        for(int i=0;i<n;i++)
            printf("%d\n",ans[i]);
    }
    return 0;
}

2，查找第K小或大（第k大可以转化成num-k+1小元素）元素：

poj-2985:

题意：有一群猫，现在给它们编号，然后组队，0 1 2 代表 1 号和 2 号的队伍合并。 1 4 询问第 4 大的队伍 Size 是多大。

分析：并查集处理集合，动态更新第K值用树状数组，具体的看注释

时间复杂度是：log(n)^2

#include <iostream>
#include <cstdio>

using namespace std;

#define MAXN 300000

int rank[MAXN],sum[MAXN],fa[MAXN];//rank表示集合的大小，初始为1

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

void update(int x,int d)
{
    while(x<=MAXN)
    {
        sum[x]+=d;//d=1或-1
        x+=lowbit(x);
    }
}

int query(int x)
{
    int s=0;
    while(x>0)
    {
        s+=sum[x];
        x-=lowbit(x);
    }
    return s;
}

int find(int x)
{
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}

int main()
{
    int i,n,m,q,x,y,k,l,r;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        fa[i]=i;
        rank[i]=1;
    }
    update(1,n);//初始状态值为1的有n个，（用线段树的思想理解就是第1-r这个区间都有1个值）
    int num=n;

    for(i=1;i<=m;i++)
    {
        scanf("%d",&q);
        if(q==0)
        {
            scanf("%d%d",&x,&y);
            x=find(x);
            y=find(y);
            if(x==y) continue;
            update(rank[x],-1);//即将集合大小为rank[x]的总数减1，在树状数组上表示为和-1
            update(rank[y],-1);
            update(rank[x]+rank[y],1);
            fa[y]=x;
            rank[x]+=rank[y];
            num--;
        }
        else
        {
            scanf("%d",&k);
            k=num-k+1;//转换成求k小
            l=1;
            r=n;
            while( l <= r)//二分逼近求k小，跟线段树类似
            {
                int m=(l+r)>>1;
                if(query(m) >= k)
                    r=m-1;//query(m)是前m的和，大于k表明在前1-m这段有大于k个值存在，即k应小于m
                else
                    l=m+1;
            }
            printf("%d\n",l);
        }
    }
    return 0;
}

另外贴一个时间复杂度是log(n)的写法，看这里

#include<stdio.h>
#include<string.h>
#define maxn 300000
int a[maxn],c[maxn],p[maxn];//值为i的数有i个
int find(int x){return x==p[x] ? x : p[x]=find(p[x]);}
int lowbit(int x){
    return x&-x;
}
void update(int x,int d){
    for(;x<=maxn;x+=lowbit(x))
        c[x]+=d;
}//因为是从左往右手动求和了，所以也不需要sum()操作了
int find_kth(int k)//太神奇了(大概是以前没有完全领会)，log(n)复杂度
{
    int ans = 0, cnt = 0, i;
    for (i = 20; i >= 0; i--)//利用二进制的思想，把答案用一个二进制数来表示
    {
        ans += (1 << i);
        if (ans >= maxn|| cnt + c[ans] >= k)
            //这里大于等于k的原因是可能大小为ans的数不在c[ans]的控制范围之内，所以这里求的是 < k
            ans -= (1 << i);
        else
            cnt += c[ans];//cnt用来累加比当前ans小的总组数
    }//求出的ans是累加和（即小于等于ans的数的个数）小于k的情况下ans的最大值，所以ans+1就是第k大的数
    return ans + 1;
}
/*
因为要求第k小的数，所以要从左往右加过去，
上述过程其实就是把树状数组的求和操作逆向，从左往右求和，
边求和边判断控制范围内比当前值要小的数是否超过或等于k,如果是则跳回兄弟节点(ans-=(1<<i))
如8+4=12，假如12不满足要求，则重新变回8，下一次就加2,8+2=10，即跳到10控制的位置
上述累加过程不会重复计算，因为
比如15=8+4+2+1，数字依次为8  12  14  15，每次累加后的值都与前面的值无关，i小于其二进制末尾0的个数
即c[8] 、c[12] 、c[14]、 c[15]相加的话不会重复计算，再如11=8+2+1;数字依次为8 10 11，c[8],c[10],c[11]
各自控制着自己的范围，不会重复累加，所以就可以用cnt来累加前面的结果，最后cnt+c[ans]就表示了值<=ans的个数
简言之：上述的各个数字两两间控制的范围不会相交
*/
int main()
{
    int i,n,m,q,x,y,k,l,r;
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++) p[i]=i;
    for(i=1;i<=n;i++) a[i]=1;
    update(1,n);//初始状态值为1的数有n个
    int num=n;
    for(i=1;i<=m;i++)
    {
        scanf("%d",&q);
        if(q==0)
        {
            scanf("%d%d",&x,&y);
            x=find(x);
            y=find(y);
            if(x==y) continue;
            update(a[x],-1);
            update(a[y],-1);
            update(a[x]+a[y],1);
            p[y]=x;
            a[x]+=a[y];
            num--;//合并集合
        }
        else 
        {
            scanf("%d",&k);
            k=num-k+1;//转换为找第k小的数
            printf("%d\n",find_kth(k));
        }
    }
    return 0;
}

PS:其他方法查询第K小元素看这里

3，求逆序数

首先使用query(x)查询比x小的数出现了几个，然后update(x,1)把x更新进去。
比如
4 3 1 2
i=0 : query(4)==0(说明比4小的数还未出现),那么当前ans+= i-query(4);

update(4,1);

i=1 : query(3)==0, ans+=i-query(3)->ans=1;

update(3,1);

。。。。

i-query()可以这样理解：本来第i个数出现时，假如没有逆序数，则query(x)应该返回i即前面的数都在x前面，但是只返回query(x)，故还有i-query(x)个数大于x且出现的早于x.即产生的逆序数对。

poj-3067

题意：有两排城市，这两排之间有一些城市之间有连接的道路，给出所有道路，问有多少道路是相交的。

分析：求逆序数。我们先把所有的道路按照a升序，a相同时b升序的方法排列。这样从头至尾便利，对于每条道路，我们只需要知道它之前有多少道路的b大于等于它的b就可以了，所以我们只要知道前面有多少b小于它的再用下标减去就可以了。而这个求有多少小于的过程就用树状数组来实现。我们每看到一条边，就把它的b作为下标，把树状数组对应位进行修改。这样一来，树状数组所有下标小于该道路的b的数的总和就是我们要求的b小于该道路的道路数。(自己画个图便于理解)

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define MAXN 2005
int N,M,K;
long long ans;
struct ci
{
    int e,w;
    bool operator <(const ci & a) const
    {
        if(e==a.e)
            return w<a.w;
        return e<a.e;
    }
}line[MAXN * MAXN];
int sum[MAXN];
int lowbit(int x)
{
    return x&(-x);
}

void update(int x,int val)
{
    while(x <= MAXN)
    {
        sum[x] += val;
        x += lowbit(x);
    }
}

long long query(int x)
{
    long long s=0;
    while(x>0)
    {
        s += sum[x];
        x -= lowbit(x);
    }
    return s;
}

int main()
{
    int t;
    int set=1;
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        memset(sum,0,sizeof(sum));
        scanf("%d%d%d",&N,&M,&K);
        for(int i=0;i<K;i++)
            scanf("%d%d",&line[i].e,&line[i].w);
        sort(line,line+K);
        for(int i=0;i<K;i++)
        {
            ans+=i-query(line[i].w);
            update(line[i].w,1);
        }
        printf("Test case %d: %I64d\n",set++,ans);
    }
    return 0;
}

PS:求逆序数还有归并排序，当然线段树也行。

 二维树状数组：

+++还没看的...