蓝桥杯重要考点—树状数组

Posted 2023-04-01 Libert_AC

树状数组经典操作

1、修改某一段区间的值   add

2、求某一段区间的前缀和  sum

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


int add(int x, int c)
    for(int i = x; i <= n; i += lowbit(i)) tr[i] += c;


int sum(int x)
    int res = 0;
    for(int i = x; i ; i -= lowbit(i)) res += tr[i];
    return res;

例题：

第一题：楼兰图腾

在完成了分配任务之后，西部314 来到了楼兰古城的西部。

相传很久以前这片土地上(比楼兰古城还早)生活着两个部落，一个部落崇拜尖刀(V)，一个部落崇拜铁锹(∧)，他们分别用 V 和 ∧ 的形状来代表各自部落的图腾。

西部 314 在楼兰古城的下面发现了一幅巨大的壁画，壁画上被标记出了 n 个点，经测量发现这 n 个点的水平位置和竖直位置是两两不同的。

西部 314 认为这幅壁画所包含的信息与这 n 个点的相对位置有关，因此不妨设坐标分别为 (1,y1),(2,y2),…,(n,yn)，其中 y1∼yn 是 1 到 n 的一个排列。

西部 314 打算研究这幅壁画中包含着多少个图腾。

如果三个点 (i,yi),(j,yj),(k,yk) 满足 1≤i<j<k≤n且 yi>yj,yj<yk，则称这三个点构成 V 图腾;

如果三个点 (i,yi),(j,yj),(k,yk)满足 1≤i<j<k≤n 且 yi<yj,yj>yk，则称这三个点构成 ∧ 图腾;

西部 314 想知道，这 n个点中两个部落图腾的数目。

因此，你需要编写一个程序来求出 V 的个数和 ∧ 的个数。

输入格式

第一行一个数 n。

第二行是 n 个数，分别代表 y1，y2,…,yn

输出格式

两个数，中间用空格隔开，依次为 V 的个数和 ∧ 的个数。

数据范围

对于所有数据，n≤200000，且输出答案不会超过 int64。
y1∼yn 是 1 到 n 的一个排列。

输入样例：

5
1 5 3 2 4

输出样例：

3 4

分析样例，我们就知道是找当前点 前面比他大的 乘以 后面也比他大的 ，两个数量相乘即是V个数

同理倒的也是如此

那我们从前面求一遍，再从后面求一遍即可

怎么与树状数组相关呢，每次加进去 add(y, 1)， 因为是全排列，加进去的就是当前的位置和个数

要求的就是前面位置 或者后面位置 的数量，这就是sum了

求前面比他大的，不就是求 sum(n) - sum(y) ，也就是  y  + 1 ——n的个数

再初始化树状数组为0，反过来加一遍，就相当于反过来求

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

const int N = 200010;
typedef long long LL;
int n;
int great[N], lower[N], tr[N], a[N];

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


int add(int x, int c)
    for(int i = x; i <= n; i += lowbit(i)) tr[i] += c;


int sum(int x)
    int res = 0;
    for(int i = x; i ; i -= lowbit(i)) res += tr[i];
    return res;


int main()
    scanf("%d", &n);
    
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    
    for(int i = 1; i <= n; i++)
        int y = a[i];
        great[i] = sum(n) - sum(y);   //正着求 y + 1 到 n
        lower[i] = sum(y - 1);        //      1 到 y - 1
        add(y, 1);
    
    
    memset(tr, 0, sizeof tr);
    LL res1 = 0, res2 = 0;
    for(int i = n; i ; i --) 
        int y = a[i];
        res1 += great[i] * (LL)(sum(n) - sum(y));
        res2 += lower[i] * (LL)sum(y - 1);
        add(y, 1);
    
    
    printf("%lld %lld", res1, res2);
    return 0;

第二题：一个简单的整数问题

给定长度为 N 的数列 A然后输入 M 行操作指令。

第一类指令形如 C l r d，表示把数列中第 l∼r个数都加 d。

第二类指令形如 Q x，表示询问数列中第 x 个数的值。

对于每个询问，输出一个整数表示答案。

输入格式

第一行包含两个整数 N 和 M。

第二行包含 N 个整数 A[i]。

接下来 M 行表示 M 条指令，每条指令的格式如题目描述所示。

输出格式

对于每个询问，输出一个整数表示答案。

每个答案占一行。

数据范围

1≤N,M≤105
|d|≤10000
|A[i]|≤109

输入样例：

10 5
1 2 3 4 5 6 7 8 9 10
Q 4
Q 1
Q 2
C 1 6 3
Q 2

输出样例：

4
1
2
5

这道题就很经典了

如果你用差分去求的话，每次修改完之后重新就要求前缀和，为O（n)级别肯定超时

但是使用树状数组维护前缀和，只需要O(logn)

要加以进去的就是差分数组，add(i, a[i] - a[i- 1])

树状数组维护的是前缀和，求某一个数，就是sum(x)

#include<iostream>
using namespace std;

const int N = 100010;
typedef long long LL;
int n, m;
int a[N], tr[N];

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


void add(int x, int c)
    for(int i = x; i <= n; i += lowbit(i)) tr[i] += c;


int sum(int x)
    int res = 0;
    for(int i = x; i; i -= lowbit(i)) res += tr[i];
    return res;


int main()
    scanf("%d%d", &n, &m);
    
    for(int i = 1; i <= n; i++) 
        scanf("%d", &a[i]);
        add(i, a[i] - a[i - 1]);
    
    
    while(m--)
        string op;
        int l, r, d;
        cin>>op;
        scanf("%d", &l);
        if(op == "C") 
            scanf("%d%d", &r, &d);
            add(l, d), add(r + 1,  -d);
        
        else
            printf("%d\\n", sum(l));
        
    
    
    return 0;

第三题：一个简单的整数问题2

还需思考，待更..

第四题：谜一样的牛

有 n头奶牛，已知它们的身高为 1∼n且各不相同，但不知道每头奶牛的具体身高。

现在这 n 头奶牛站成一列，已知第 i 头牛前面有 Ai 头牛比它低，求每头奶牛的身高。

输入格式

第 1 行：输入整数 n。

第 2..n 行：每行输入一个整数 Ai，第 i 行表示第 i 头牛前面有 Ai 头牛比它低。
（注意：因为第 1 头牛前面没有牛，所以并没有将它列出）

输出格式

输出包含 n 行，每行输出一个整数表示牛的身高。

第 i 行输出第 i 头牛的身高。

数据范围

1≤n≤105

输入样例：

5
1
2
1
0

输出样例：

2
4
5
3
1

每一只牛发现前面比他低的牛，模拟样例得到

从最后开始模拟，第ai头牛，找当前数组第ai + 1小的数 就是当前牛的身高

涉及两个操作

1、找到了，删除某头牛

2、找到该位置，第 ai + 1比他小的数

第一个在树状数组里面很好解决

第二个把树状数组初始化为1,表示该位置可以使用，sum(k) == ai + 1表示当前位置身高为k（身高为1-n），怎么找这个k，使用二分，满足二段性的

#include<iostream>
using namespace std;

const int N = 100010;
typedef long long LL;
int h[N], tr[N], ans[N];
int n;

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


void add(int x, int c)
    for(int i = x; i <= n; i += lowbit(i)) tr[i] += c;


int sum(int x)
    int res = 0;
    for(int i = x; i ; i -= lowbit(i)) res += tr[i];
    return res;


int main()
    scanf("%d", &n);
    
    for(int i = 2; i <= n; i ++) scanf("%d", &h[i]);
    
    for(int i = 1; i <= n; i ++) tr[i] = lowbit(i);
    
    for(int i = n; i; i--)
        int k = h[i] + 1;
        int l = 1, r = n;
        while(l < r)
            int mid = l + r >> 1;
            if(sum(mid) >= k) r = mid;
            else l = mid + 1;
        
        ans[i] = r;
        add(r, -1);
    
    
    for(int i = 1; i <= n; i++) printf("%d\\n", ans[i]);
    return 0;

树状数组求逆序数 。，。 蓝桥杯 小朋友排队

先介绍一下树状数组。什么是树状数组呢？树状数组(Binary Indexed Tree(BIT), Fenwick Tree)是一个查询和修改复杂度都为log(n)的数据结构。主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以在log(n)的复杂度下进行范围修改，但是这时只能查询其中一个元素的值(如果加入多个辅助数组则可以实现区间修改与区间查询)。（度娘万岁）

假设A[]数组为存储原来的值得数组，C[]为树状数组。

我们定义：C[i] = A[i - 2^k + 1] + ..... + A[i]  其中k为i用二进制表示时的末尾0的个数。例如：i= 10100,则k = 2，i = 11000，则k = 3；为了方便我直接写的是二进制的i，请读者注意。

先介绍一下lowbit 吧  lowbit（x）=2^k k表示x在二进制形式表示下末尾0的个数比如 11000

lowbit(11000)=8 这里的lowbit是树状数组的精华 许多操作都和这个有关

lowbit(int x)//利用机器码补码的原理来求lowbit

{

    return x&(-x);

}

先说说树状数组更新的过程

我们举个例子(为了方便i的值直接写成二进制了)：i = 11000,此时k = 3；

这2^k = 3 个数即为：A[11000],A[10111],A[10110],A[10101],A[10100],A[10011],A[10010],A[10001]

C[11000] = A[11000]+A[10111]+A[10110]+A[10101]+A[10100]+A[10011]+A[10010]+A[10001]；

这里我们会发现:

A[10100]  + A[10011] +  A[10010] + A[10001] = C[10100]

而

A[10010] + A[10001] = C[10010]

A[10011] = C[10011]

所以

C[10100] = C[10010] + C[10011] + A[10100]

 

又

A[10110] + A[10101] = C[10110]

而

A[10101] = C[10101]

所以

C[10110] = C[10101] + A[10110]

 

又

A[10111] = C[10111]

 

至此我们可以得出：

C[11000] = C[10100] + C[10110] + C[10111] + A[11000]

 

到这里我们可以得出：

k的值就表示子树的个数，子树即为树状数组的元素。

那么更新的时候怎么更新父节点呢？ 这里就要用上lowbit了 

由于子树都是由父节点一步一步拆分而来 所以可以依葫芦画瓢 还原回去

由上可以观察出 c[]中 子节点是父节点最高位1不断右移动的过程 还原的话 p=i+lowbit(i) p为父节点 i为子节点 有了这个 updata就很容易实现了

updata(int i,int x,int n)//i表示节点, x表示值，n表示范围
{
while(i<n)
{
c[i]+=x;
i=i+lowbit(i);
}
}

最后说说求和的问题

我们既然定义了c[]数组 那么getsum(x)的时候 当然是要用上 c[]的 那么怎么用呢？

我们知道c[i]存储了i到i-2^k+1数之和 那我们要求1~i和的时候 c[i]数去了2^k个数

我们让i-2^k 这个时候 最低位的1消去了 然后我们重复上述过程 不断的消去最低位1  就可以求出1~i的和了

int getsum(int i)
{
int sum=0;
while(i>0)
{
sum+=c[i];
i=i-lowbit(i);
}
return sum;
}

 

好了这里介绍完了树状数组 现在来说下怎么求逆序对

上篇介绍了用归并思想求逆序数 这里还可以用权值线段树的思想来求

给定一个数列 比如 1 8 9 2 7 3  我们定义一个区间（如果区间太大可以用离散话对应）

然后将这些数据依次插入 然后看在插入的时候 有多少比他大的数在区间里面 这就是这个数造成的逆序数 统计起来就是这个序列的逆序数了

 

对于这道题目而言关键是要把这道题目巧妙的转化为求逆序对的问题

是最简单的关于逆序对的题目，题目大意是给出一个序列，求最少移动多少步可能使它顺序，规定只能相邻移动。
相邻移动的话，假设a b 相邻，若a<b 交换会增加逆序数，所以最好不要做此交换；若a==b 交换无意思，也不要进行此交换；a>b时，交换会减少逆序，使序列更顺序，所以做交换。
由上可知，所谓的移动只有一种情况，即a>b，且一次移动的结果是逆序减1。假设初始逆序是n，每次移动减1，那么就需要n次移动时序列变为顺序。所以题目转化为直接求序列的逆序便可以了

 引用自http://blog.csdn.net/suwei19870312/article/details/5295135

#include <stdio.h>
#include <string.h>

#define maxn 1000010
typedef long long LL;

LL T1[maxn], T2[maxn], unhappy[maxn];
LL A[maxn], B[maxn], N; // B[]存储交换次数

LL lowBit(LL x) { return x & -x; }

void update(LL x, LL *arr) {
	for ( ; x < maxn; x += lowBit(x))
		++arr[x];
}

LL getSum(LL x, LL *arr) {
	LL sum = 0;
	for ( ; x; x -= lowBit(x))
		sum += arr[x];
	return sum;
}

int main() {
	
	LL i, j;
	LL ret = 0;

	for (i = 1; i < maxn; ++i)
		unhappy[i] = unhappy[i-1] + i;

	scanf("%lld%lld", &N, &A[0]);
	update(A[0] + 1, T1);
	for (i = 1; i < N; ++i) { // 当前点跟左边的点产生的逆序对数
		scanf("%lld", &A[i]);
		update(A[i] + 1, T1);
		B[i] = i+1 - getSum(A[i] + 1, T1);
	}
	for (i = N - 1; i >= 0; --i) { // 当前点跟右边的点产生的逆序对数
		update(A[i] + 1, T2);
		ret += unhappy[B[i] + getSum(A[i], T2)];
	}

	printf("%lld\n", ret);

	return 0;
}

前面的一些整理引用了大佬http://blog.csdn.net/ljd4305/article/details/10101535一些引例