学习笔记（3）线段树

        线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
        对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。
        使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。

对于任意节点 i 来说，它的左儿子的序号为 2*i，右儿子序号则是2*i+1。之所以开辟空间为4N是为了用来表示满二叉树的数组，即序号为9~15的节点也留出了左右子树的空位。

创建线段树

void build(int node,int l,int r)
{
	if(l == r)
	{
		tree[node] = a[l];
		return;
	}
	int mid = (l+r)/2;
	build(node*2,l,mid);
	build(node*2+1,mid+1,r);
	tree[node] = tree[node*2] + tree[node*2 + 1];
}

单点更新

// 单点更新，n为更新值，index为更新点，lr为更新范围
void update(int n,int index,int l,int r,int node)
{
	if(l==r)
	{
		tree[node] = n; // 更新方式，可以自由改动
		return;
	}
	int mid = (l+r) / 2;
	// push_down(node,mid-l+1,r-mid); 若既有点更新又有区间更新，需要这句话
	if(index <= mid)
	{
		update(n,index,l,mid,node*2);
	}
	else
	{
		update(n,index,mid+1,r,node*2+1);
	}
	tree[node] = tree[node*2] + tree[node*2 + 1];
}

区间更新

// 区间更新，lr为更新范围，LR为线段树范围，add为更新值
void update_range(int node,int l,int r,int L,int R,int add)
{
	if(l <= L && r >= R){
		lz[node] += 1LL*add;
		tree[node] += 1LL*(R - L + 1)*add; // 更新方式
		return;
	}
	push_down(node,L,R);
	int mid = (L+R) / 2;
	if(mid >= l) update_range(node*2,l,r,L,mid,add);
	if(mid < r) update_range(node*2 + 1,l,r,mid+1,R,add);
	tree[node] = tree[node*2] + tree[node*2 + 1];
}

区间查找

// 区间查找
LL query_range(int node,int L,int R,int l,int r)
{
	if(l <= L && r >= R) return tree[node];
	push_down(node,L,R);
	int mid = (L+R) / 2;
	LL sum = 0;
	if(mid >= l) sum += query_range(node*2,L,mid,l,r);
	if(mid < r) sum += query_range(node*2 + 1,mid+1,R,l,r);
	return sum;
}

Pushdown

void push_down(int node,int l,int r)
{
	if(lz[node]){
		int mid = (l+r) / 2;
		lz[node*2] += lz[node];
		lz[node*2 + 1] += lz[node];
		tree[node*2] += 1LL*(mid - l + 1)*lz[node];
		tree[node*2 + 1] += 1LL*(r - mid)*lz[node];
		lz[node] = 0;
	}
}

A Simple Problem with Integers

Time Limit: 5000MS		Memory Limit: 131072K
Total Submissions: 197009		Accepted: 60782
Case Time Limit: 2000MS

Description

You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A1, A2, ... , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of Aa, Aa+1, ... , Ab. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of Aa, Aa+1, ... , Ab.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

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

Sample Output

4
55
9
15

Hint

The sums may exceed the range of 32-bit integers.

---

 题意解释：

现有N个数字组成的数组A1~AN，

操作"C a b c"：给Aa~Ab都分别加上c；

操作"Q a b"： 求出Aa~Ab的总和；

对于求和操作，输出正确的值；对于修改操作执行正确的修改；

---

分析

 考虑到数据范围The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.，使用前缀法来求和的话，肯定会TLE。所以这题就是要用线段树来写。。。直接套模板就可以

AC代码

#include<iostream>
#include<string>
#include<stdio.h>
#define LL long long
#define MAX 1005000

#define N MAX
using namespace std;

LL tree[1005000]; // 线段树
LL lz[1005000]; // 延迟标记
LL a[1005000];
LL n,q;

void init()
{
	for(int i=0;i<N;++i)
	{
		tree[i] = lz[i] = 0;
	}

	for(int i=1;i<=n;++i)
	{
		scanf("%lld",&a[i]);
	}
}

// 创建线段树
void build(int node,int l,int r)
{
	if(l == r)
	{
		tree[node] = a[l];
		return;
	}
	int mid = (l+r)/2;
	build(node*2,l,mid);
	build(node*2+1,mid+1,r);
	tree[node] = tree[node*2] + tree[node*2 + 1];
}

// 单点更新，n为更新值，index为更新点，lr为更新范围
void update(int n,int index,int l,int r,int node)
{
	if(l==r)
	{
		tree[node] = n; // 更新方式，可以自由改动
		return;
	}
	int mid = (l+r) / 2;
	// push_down(node,mid-l+1,r-mid); 若既有点更新又有区间更新，需要这句话
	if(index <= mid)
	{
		update(n,index,l,mid,node*2);
	}
	else
	{
		update(n,index,mid+1,r,node*2+1);
	}
	tree[node] = tree[node*2] + tree[node*2 + 1];
}

void push_down(int node,int l,int r)
{
	if(lz[node]){
		int mid = (l+r) / 2;
		lz[node*2] += lz[node];
		lz[node*2 + 1] += lz[node];
		tree[node*2] += 1LL*(mid - l + 1)*lz[node];
		tree[node*2 + 1] += 1LL*(r - mid)*lz[node];
		lz[node] = 0;
	}
}

// 区间更新，lr为更新范围，LR为线段树范围，add为更新值
void update_range(int node,int l,int r,int L,int R,int add)
{
	if(l <= L && r >= R){
		lz[node] += 1LL*add;
		tree[node] += 1LL*(R - L + 1)*add; // 更新方式
		return;
	}
	push_down(node,L,R);
	int mid = (L+R) / 2;
	if(mid >= l) update_range(node*2,l,r,L,mid,add);
	if(mid < r) update_range(node*2 + 1,l,r,mid+1,R,add);
	tree[node] = tree[node*2] + tree[node*2 + 1];
}

// 区间查找
LL query_range(int node,int L,int R,int l,int r)
{
	if(l <= L && r >= R) return tree[node];
	push_down(node,L,R);
	int mid = (L+R) / 2;
	LL sum = 0;
	if(mid >= l) sum += query_range(node*2,L,mid,l,r);
	if(mid < r) sum += query_range(node*2 + 1,mid+1,R,l,r);
	return sum;
}
int main()
{

	scanf("%lld%lld",&n,&q);
	init();
	build(1,1,n);
	for(int i=1;i<=q;i++)
	{
		char ch;
		cin>>ch;
		if(ch=='Q')
		{
			LL a,b;
            scanf("%lld%lld",&a,&b);
			printf("%lld\n",query_range(1,1,n,a,b));
			// cin>>a>>b;
			// cout<<query_range(1,1,n,a,b)<<endl;

		}
		if(ch=='C')
		{
			LL a,b,c;
			//cin>>a>>b>>c;
            scanf("%lld%lld%lld",&a,&b,&c);
			update_range(1,a,b,1,n,c);
		}
	}
	return 0;
}

emmm留几个坑，以后来填：

懒惰标记的意义以及时间复杂度分析；

补充线段树的应用范围，譬如：求和、区间内最大差值；

补充实际应用的例题，熟练修改并使用模板；