【学习笔记+习题集】(树状数组和线段树)(8411字)

目录

板块一:树状数组

引子:lowbit

1、存入数据(单点修改)

2、区间查询

3、区间修改和单点查询(差分数组)

4、求逆序对(两种版本)

5、二维的树状数组

6、树状数组求区间最大值

7、树状数组求第k大的数(???做到了再说)

板块二:线段树

前言:

1、建树:

2、区间修改+区间查询


板块一:树状数组

据说树状数组写起来比线段树简单,不过对于初学者的博主来说还是很抽象。

这是一个非常神奇的数据结构,虽然是一维的数组但能存储树形的结构。

首先定义N为数组的长度,那么从1到N我们可以这样分类,从下往上,我们可以得到这样几种类型的数。

用我自己好理解的方式思考。

第零层:最多是2^0的倍数(奇数):*****1

第一层:最多是2^1的倍数***10

第二层:最多是2^2的倍数*****100

………………

首先,树状数组是完备的。奇数+2的倍数+ ………… = 奇数 + 偶数 = 所有下标。

这些数是有限的,因为有上界N,有种筛法的味道。

这些数字包含了所有可以引用的下标。

根据最低位数,我们将其分层。

引子:lowbit

为了方便索引树状数组里面的下标,我们构造一种函数lowbit,来获取最低位的数,也就是判断究竟是2的几次幂的倍数,是第几层。

再计算机中数字用补码储存。

1:补码000001, -1:11111110(这里位数不做考虑了)

1和-1的原码是一毛一样的,就是符号位不同。正数的补码是本身,负数的补码是原码取反(除符号位)加1,虽然符号位和1取反码加一不同,但是后面&后就没有区别了。按位取与。

x & -x 和 x & (~x + 1)是一样的,只不过前者写起来简洁。

如果原来的数是0*********1*1000000000000000000

那么按相反数是1*********0*1000000000000000000

那么这结果就是0000000001000000000000000000

就先不管符号位,因为后面会去掉。这样相反数的原码是一样的,求负数补码的过程中,先各位取反,那么最低位1的位置是零,其后的都是1,加上1之后,进位,一直进到最低位,此刻其他位都是相反的,这时候按位取与就可以得到是几的倍数。

板子:

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

1、存入数据(单点修改)

数据结构首先它能存储数据,我们要如何存入数据?

其实存入数据也是一种单点修改的过程,就是把原来的0改成了某个特定的数罢了。

有序的数据结构,意味着我们要有序的存入数据,从而实现数据结构的维护。

树状数组父节点和子节点的关系:

也就是第0层和第1层之间的关系是如何的,我们要想使得最多是2的倍数,变成最多是4的倍数我们就需要将最低位的1变成零。也就是+1, +2, +4,刚好是加最低位所代表的数。

为什么不能加别的呢?如果是加别的,比如奇数,那么就无法有序的查询下一个父节点了。

通过这样,我们可以有序得查询下一个父节点。

树状数组的性质:

每一层是上一层通过进位得到,因而每层的长度都是上一层的两倍,这也是为什么可以得到logn的查询效率的原因,数学上证明博主不懂为什么这么构造,还需要慢慢体会。

板子:

void add(int x, int k) {
	while (x <= n) {//不能超出上界
		tree[x] += k;//父节点
		x += lowbit(x);
	}
}

2、区间查询

像台阶一样一直去掉最低位,一级级得到几项和,最终得到前几项和。

没时间画图。

板子:

int ask(x){
	int sum = 0;
	for(int i=x;i;i-=lowbit(i)){
		sum+=t[i];
	}
	return sum;
}

得到前几项和,就可以通过两次调用,做差得到某个区间的和。

练习1:hdoj1541

我只想说这是一道毒题,毒点是这里没有说多组数据,但是hdoj上默认输入多组数据,也是醉了。

wa了n次,哭死。

题目的意思是让我们求星星下方,左方所有的其他的星星。

批注:这道题由于x和y都是按照升序排的,所以后面的星星一定在前面的星星上面,或者同一个位置,所以我们只需要考虑先前放的x即可。

还有一件事,就是注意add/updata函数的上界的范围,数组开的大小!!。

这里没有给出坐标的上界,而这里树状数组存储又是横坐标,所以只能一直到坐标最大值,不要把星星的个数当作是上界!!!。

注意,树状数组坐标为0的话,sum会缺失,所有要加一。

还要就是,先求sum再加,这样就不用减一了。

代码:

#include 
using namespace std;
const int N = 32005;
int tree[N], n, ans[N];
int lowbit(int x) {
	return x & -x;
}
void add(int x, int k) {
	while (x <= N) {
		tree[x] += k;
		x += lowbit(x);
	}
}
int sum(int x) {
	int res = 0;
	while (x > 0) {
		res += tree[x];
		x -= lowbit(x); 
	}
	return res;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	while (cin >> n) {
    	memset(tree, 0, sizeof(tree));
    	memset(ans, 0, sizeof(ans));
    	for (int i = 0; i < n; i++) {
	     	int x, y;
	    	cin >> x >> y;
	    	x++;//防止坐标为0,如果坐标为零的话sum的时候可能有问题。
	    	ans[sum(x)]++;
	    	add(x, 1);
    	}
     	for (int i = 0; i < n; i++) {
	    	cout << ans[i] << '\n';
    	}
	}
	return 0;
} 

3、区间修改和单点查询(差分数组)

终于悟了。

在使用区间修改的时候,我们的树状数组不再是普通的数组了,其实存储的是差分,是区间左端和区间右端加一的差值。

首先,对于某个区间而言,内部都加上或者减去一个量,区间内的差分不变,差值不变。

例如:0 0 0 1 1 1 1 1 3 3 3》》》0 0 0 2 2 2 2 2 3 3 3。

而且,两侧区间内部的的差值不变。

然后,我们从树的最底层来看,我们考察相邻两个数的差值,我们发现,改变的只有,第一个1和第一个3,由于更新的传递性,所有包含这个点的父节点的两端差值都受到了影响,我们只需进行两次单点更新即可。

最后,为了获取该点的真实值,我们只需要进行前缀求和即可。着实妙哉。

练习1:hdoj 1556

下面是代码:

#include 
using namespace std;
const int N = 1e5 + 5;
int tree[N], n;
int lowbit(int x) {
	return x & -x;
}
int sum(int x) {
	int res = 0;
	while (x > 0) {
		res += tree[x];
		x -= lowbit(x);
	}
	return res;
}
void add(int x, int k) {
	while (x <= n) {
		tree[x] += k;
		x += lowbit(x);
	}
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	while (cin >> n, n) {
		for (int i = 0; i <= n; i++) {
			tree[i] = 0;
		}
		int a, b;
		for (int i = 1; i <= n; i++) {
			cin >> a >> b;
			add(a, 1);
			add(b + 1, -1);
		}
		for (int i = 1; i <= n; i++) {
			if (i == 1) {
				cout << sum(i);
			} else {
				cout << ' ' << sum(i);
			}
		}
		cout << '\n';
	}
	return 0;
}

练习2:洛谷P3368

 批注:这里和上面那道题都是从零开始不一样,这里有初始值,我们不能简单的add这个点,因为我们需要的是差分数组,所以,我们要把一个点看成区间长度为1的区间修改。

代码:

#include 
#define ll long long
using namespace std;
const int N = 5e5 + 5;
int tree[N] = {0}, n;
int lowbit(int x) {
	return x & -x;
}
void add(int x, int k) {
	while (x <= n) {
		tree[x] += k;
		x += lowbit(x);
	}
}
int sum (int x) {
	int sum = 0;
	while (x > 0) {
		sum += tree[x];
		x -= lowbit(x);
	}
	return sum;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int m;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		int c;
		cin >> c;
		add(i, c);
		add(i + 1, -c);
	}
	while (m--) {
		int flag;
		cin >> flag;
		if (flag == 1) {
			int x, y, k;
			cin >> x >> y >> k;
			add(x, k);
			add(y + 1, -k);
		} else {
			int c;
			cin >> c;
			cout << sum(c) << '\n';
		}
	}
	return 0;
}

4、求逆序对(两种版本)

大量阅读后发现两种板子,个人觉得第一种写起来更加简洁而且我更好理解。

公共部分:单点修改和前缀和查询

int lowbit(int x) {
	return x % -x;
}//最低位
void add(int x, int k) {
	while (x <= n) {
		tree[x] += k;
		x += lowbit(x);
	}
} //单点修改
int sum(int x) {
	int sum = 0;
	while (x > 0) {
		sum += tree[x];
		x -= lowbit(x);
	}//前缀查询
	return sum;
}

 两种版本的思想都是一样的,本质都是离散化。

版本A:间接排序+从大到小

bool cmp(int x,int y) {
	if(a[x] == a[y]) return x > y;
	return a[x] > a[y];
}
int main() {
	long long ans=0;
	cin >> n;
	for(int i = 1;i <= n; i++)
	cin >> a[i], d[i] = i;
	sort(d + 1,d + n + 1,cmp);	
	for(int i = 1;i <= n; i++) {
		add(d[i]);
		ans += sum(d[i] - 1);
	}
	cout << ans;
	return 0;
}

解读:

所谓的逆序对或者是逆序数,呃呃,这个就是线性代数里面内容,不过逆序数也就是,冒泡排序所需要交换的次数。对于一个数的逆序我们应该怎么求?我们只需要看看前面有几个数比这个数大就可以了,这样我们就可以通过相邻两个数交换把这个数放到正确的位置,这也是冒泡排序的原理。

一个序列的逆序数是每一个数的逆序数之和。

我发现很多人都不喜欢讲清楚数组的含义,直接上代码,真心累。

这里a数组是原始数据,自始至终没有变动,d数组存的a数组的编号。

首先,通过排序。这里是间接排序,根据a数组内的大小来进行排序,貌似这里面有种指针的联系,尽管是两个数组,但是在排序的过程中始终都是有联系的。注意,这里相同元素的处理,因为我们这里是从大到小排序,所以对于相同的元素,我们取大的,后面讲。

然后,排序完之后,我们得到一个d的数组,里面的对于d[i] = x,i是代表这是第几大的数,x是a中对应数的下标。

我们首先拿第一大的数,更新该元素原来位置的下标x,x象征这原来数组的各个元素的位置,而i则是优先级体现。

然后,我们记录前缀和,注意,后面更新的数一定比前面更新的数要小!!!,所以说,只要前面存在更新过的点,只要前面有数,说明,比这个数大的数的位置在这个数前面!!!,那么这个数的逆序数就是区间0到x里面所有的数,也就是sum(x),但是这是个闭区间,我们也把x的存在放进去了,所以要减一。

依次求和,我们就得到了整个序列的逆序,long long!!!。

回答问题,如果说元素是一样大的话,我们默认,后面更新的比前面更新的要小,但是这是一样的,实际上两者之间没有逆序关系,如果说我们把标号小的放前面,会导致其被计入后面标号大的区间内,导致多计算了逆序数。

可以简单的概括为,求d数组内部的正序数,因为只要是正序的就意味着被计入下一个数的区间内。

大功告成。

B:结构体+从小到大

struct point
{
    int num,val;
} a[500010];
bool cmp(point q,point w)
{
    if(q.val == w.val)
        return q.num < w.num;
    return q.val < w.val;
}
int main()
{
    scanf("%d",&n);
    for(int i = 1;i <= n; i++)
        scanf("%d", &a[i].val),a[i].num = i;
    sort(a+1, a+1+n, cmp);
    for(int i = 1; i <= n; i++)
        ranks[a[i].num] = i;
    for(int i = 1; i <= n; i++)
    {
        insert(ranks[i],1);
        ans += i-query(ranks[i]);
    }
    printf("%lld",ans);
    return 0;
} 

这个感觉有点绕。

这里是从小到大排序,利用了结构体。

这里ranks数组里面存储的是对应下标的优先级ranks[i] = x这里的i才是下标,注意!。

首先放入原来数组下标为1的数的优先级。这里因为是第一个数,所以,它前面的数(含本身)为一。最小,优先级最高rank1

那么对于第i个数,它前面的数(含本身)共有i个数,我们要找出其中比它大的数,我们是减去其中比它小的数,query(ranks[i])。

第一个数更新的时候,这里的树状数组存的是优先级和上面的相反,比它优先级低(rank100,是值小的)的都会受到影响,因为会被包含在较低优先级的区间内部。

所以query查询的是在这个树前面优先级比它低的数(含本身),也就是比它小的数,相减得到。

同样,这里如果有相同的元素的话,小的放前面,rank会小,这样可以多计算一次,以便于和i同时增加相互抵消。否则i增加会带来麻烦。i表示下标!!。

5、二维的树状数组

一维的树状数组已经是二维的了,再增加一维可能就是三维的数据结构了,树状数组真心累。

可能不靠谱的想象,可以把二维树状数组看成,两个树状数组垂直正交构成的十字形的“树”。

二维树状数组里面存的是矩阵,我想里面应该也可以读取一维数组,也就是某一矩阵的某一行。不过这样就大材小用了,这里主要目的是为了求出前i行,前j列,的子矩阵之和。

板子:

单点更新。

void update(int i, int j, int num){
    for(int x = i; x< first; x += lowbit(x))
        for(int y = j; y < last; y += lowbit(y))
            c[x][y] += num;
}

前缀求和:

int sum(int i, int j){
    int s = 0;
    for(int x = i; x > 0; x -= lowbit(x)) {
        for(int y = j; y > 0; y -= lowbit(y)) {
            s += c[x][y];
        }
    }
    return s;
}

大概是这样的,三维空间里面大大小小的方块,下面投影的是原始的二维数据矩阵。

【学习笔记+习题集】(树状数组和线段树)(8411字)_第1张图片

6、树状数组求区间最大值

至此,我们有了三种不同类型的树状数组,前缀和类型,差分类型,最值类型,为什么花样这么多QAQ。

首先,如何维护最大值,肯定是不可能想前缀和和差分类型一样维护的,具有不同性质的树状数组我们就要保证区间性质的方法来维护。

板子:

单点更新(区间维护):

void add(int x) {
	while (x <= n) {
		tree[x] = a[x];
		int lx = lowbit(x);
		for (int i = 1; i < lx; i <<= 1) {
			tree[x] = max(tree[x], tree[x-i]);
		}
     	x += lowbit(x);
	}		
}

 为什么这里需要一个for循环呢?如果说,我们直接单点tree[x] = max(tree[x], k),加lowbit逐级更新所有的父节点的的话。

会导致一个问题,就是,如果说我们修改的那个数的刚好的原来的最大值的话,而且,新的数比原来的数要小的话,这样就会导致,树状数组里面存了一个虚假的最大值,只是历史曾经存在过的最大值,但是并不是当前真实的最大值。

为了避免这个问题的出现,就不得不查看所有的不包含这个数的区间,但是庆幸的是,由于树状数组特殊的性质,能够更新到这个区间的子区间一定是某个数加上一个lowbit,所以我们只需要查看所有能够通过加上一个lowbit得到这个数的区间即可。

也就是这个数减去一些lowbit,而且也不需要减去所有的lowbit,因为树状数组里面的每一层的lowbit都是相同的,所以子节点的下标的lowbit一定比x要小。

区间查询:

int query(int x, int y)
{
	int ans = 0;
	while (y >= x)
	{
		ans = max(a[y], ans);
		y--;//!!!
		for (; y - lowbit(y) >= x; y -= lowbit(y))
			ans = max(tree[y], ans);
	}
	return ans;
}

模板解读:我们要查询区间[x, y]上的最大值,tree[y]表示的是某个以a[y]为末端的区间,这个区间可能很长可能很短,但是,我们要求,这个区间不能超过x否则最大值就可能取到外面了。

如果减去lowbit还在区间内说明原来的区间长度小于[x, y],直接max综合求最大值,一直求到无法这么求为止,然后再减1取掉当前的元素求最大值,继续操作,依次类推。

由于lowbit的二进制特性,这样操作可以大大加快区间的检索。

练习1:hdoj 1754

批注:注意一下,memset函数其实和for循环的速度是一样的,这里不建议用,每次清空全部可能会超时。

注意了,这里数状数组里存的最值,函数输入的是下标。

下面是代码:

#include 
using namespace std;
const int N = 2e5 + 5;
int a[N], tree[N], n;
int lowbit(int x) {
	return x & -x;
}
void update(int x) {
	while (x <= n) {
		tree[x] = a[x];
		for (int i = 1; i < lowbit(x); i <<= 1) {
			tree[x] = max(tree[x], tree[x - i]);
		}
		x += lowbit(x);
	}
}
int query(int x, int y) {
	int ans = 0;
	while (y >= x) {
		ans = max(a[y], ans);
		y--;
		while (y - lowbit(y) >= x) {
			ans = max(tree[y], ans);
			y-= lowbit(y);
		}
	}
	return ans;
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int m;
	while (cin >> n >> m) {
		for (int i = 0; i <= n; i++) {
			a[i] = 0;
			tree[i] = 0;
		}
		for (int i = 1; i <= n; i++) {
			cin >> a[i];
			update(i);
		}
		while (m--) {
			char ch;
			int x, y;
			cin >> ch >> x >> y;
			if (ch == 'Q') {
				cout << query(x, y) << '\n';
			} else {
				a[x] = y;//注意看,这里要先更改a数组
				update(x);
			}
		}
	}
	return 0;
}

7、树状数组求第k大的数(???做到了再说)

板块二:线段树

线段树拥有所有树状数组的具备的功能,但是树状数组不一定具备线段树的操作。

前言:

线段树和树状数组的类似之处,都是通过一维的的数组来表示树的数据结构。

胡乱分析:

                  1
               10   11
       100    101   110     111
1000 1001 1010 1011 1100 1101 1110 1111

首先用二进制可以发现,各个区间的标号之间的关系,当标号乘二时会得到左儿子,当标号乘二加一的时候会得到右儿子。

而且,每一层的可以存储的区间都是二的倍数增加,每一层的二进制数的位数是一样。因此,所有的标号都是存在对应区间的(如果有区间的话),这些标号是稠密的,而不是稀疏的。

因为,每层的二进制数的最大可能性是有限的,而且和当前层数的标号是一一对应的。 

1、建树:

板子:

void build(int s, int t, int p) {//s是开始点,t是结束点,p是初始标号1
  if (s == t) {//当区间长度为1的时候
    d[p] = a[s];//直接将数组里的数存入
    return;
  }
  int m = s + t >> 1;//取中间
  build(s, m, p * 2);//左儿子,左儿子的下标是母节点的下标的两倍
  build(m + 1, t, p * 2 + 1);//右儿子,右儿子的下标是母节点的两倍加1
  d[p] = d[p * 2] + d[(p * 2) + 1];//递归,从叶子节点开始,逐层更新
}

2、区间修改+区间查询

树状数组的是单点修改加区间查询,或者是区间修改单点查询,实际上,树状数组还是只能单点修改,就算是区间修改,也不过是通过差分数组实现两端两点修改来模拟区间修改。

你可能感兴趣的:(学习,数据结构,算法)