线段树模板

在自然数，且所有的数不大于30000的范围内讨论一个问题：现在已知n条线段，把端点依次输入告诉你，然后有m个询问，每个询问输入一个点，要求这个点在多少条线段上出现过；

最基本的解法当然就是读一个点，就把所有线段比一下，看看在不在线段中；

每次询问都要把n条线段查一次，那么m次询问，就要运算m*n次，复杂度就是O(m*n)

这道题m和n都是30000，那么计算量达到了10^9；而计算机1秒的计算量大约是10^8的数量级，所以这种方法无论怎么优化都是超时

因为n条线段是固定的，所以某种程度上说每次都把n条线段查一遍有大量的重复和浪费；

线段树就是可以解决这类问题的数据结构

举例说明：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次

在[0,7]区间上建立一棵满二叉树：（为了和已知线段区别，用【】表示线段树中的线段）

                                              【0,7】
                              /                                           \
                    【0,3】                                          【4,7】
                 /              \                                   /               \
       【0,1】            【2,3】                    【4,5】             【6,7】
        /      \                /     \                    /     \                  /      \
【0,0】 【1,1】    【2,2】 【3,3】    【4,4】 【5,5】    【6,6】 【7,7】

每个节点用结构体：

struct line
{
      int left,right;//左端点、右端点
      int n;//记录这条线段出现了多少次，默认为0
}a[16];

和堆类似，满二叉树的性质决定a[i]的左儿子是a[2*i]、右儿子是a[2*i+1];

然后对于已知的线段依次进行插入操作：

从树根开始调用递归函数insert

voidinsert(int s,int t,int step)//要插入的线段的左端点和右端点、以及当前线段树中的某条线段
{
      if (s==a[step].left && t==a[step].right)
      {
           a[step].n++;//插入的线段匹配则此条线段的记录+1
            return;//插入结束返回
      }
      if (a[step].left==a[step].right)  return;//当前线段树的线段没有儿子，插入结束返回
      int mid=(a[step].left+a[step].right)/2;
      if (mid>=t)   insert(s,t,step*2);//如果中点在t的右边，则应该插入到左儿子
      else if (mid<s)   insert(s,t,step*2+1);//如果中点在s的左边，则应该插入到右儿子
      else//否则，中点一定在s和t之间，把待插线段分成两半分别插到左右儿子里面
      {
           insert(s,mid,step*2);
           insert(mid+1,t,step*2+1);
      }
}

三条已知线段插入过程：

[2,5]

--[2,5]与【0,7】比较，分成两部分：[2,3]插到左儿子【0,3】，[4,5]插到右儿子【4,7】

--[2,3]与【0,3】比较，插到右儿子【2,3】；[4,5]和【4,7】比较，插到左儿子【4,5】

--[2,3]与【2,3】匹配，【2,3】记录+1；[4,5]与【4,5】匹配，【4,5】记录+1

[4,6]

--[4,6]与【0,7】比较，插到右儿子【4,7】

--[4,6]与【4,7】比较，分成两部分，[4,5]插到左儿子【4,5】；[6,6]插到右儿子【6,7】

--[4,5]与【4,5】匹配，【4,5】记录+1；[6,6]与【6,7】比较，插到左儿子【6,6】

--[6,6]与【6,6】匹配，【6,6】记录+1

[0,7]

--[0,7]与【0,7】匹配，【0,7】记录+1

插入过程结束，线段树上的记录如下（红色数字为每条线段的记录n）：

                                              【0,7】
                                                   1
                              /                                           \
                    【0,3】                                          【4,7】
                        0                                                    0
                /                \                                    /                \
       【0,1】                【2,3】               【4,5】               【6,7】
           0                          1                         2                        0
          /   \                     /      \                    /    \                   /      \
【0,0】 【1,1】 【2,2】 【3,3】 【4,4】 【5,5】 【6,6】 【7,7】
    0           0           0           0           0           0          1           0

询问操作和插入操作类似，也是递归过程，略

2——依次把【0,7】 【0,3】 【2,3】 【2,2】的记录n加起来，结果为2

4——依次把【0,7】 【4,7】 【4,5】 【4,4】的记录n加起来，结果为3

7——依次把【0,7】 【4,7】 【6,7】 【7,7】的记录n加起来，结果为1

不管是插入操作还是查询操作，每次操作的执行次数仅为树的深度——logN

建树有n次插入操作，n*logN，一次查询要logN，m次就是m*logN；总共复杂度O(n+m)*logN，这道题N不超过30000，logN约等于14，所以计算量在10^5～10^6之间，比普通方法快了1000倍；

[cpp]  view plain copy print ?

1. #include<iostream>  
2. #include<cstdio>  
3. using namespace std;  
4.   
5. int n,m,l,r;//长度n，线段数m  
6. struct line{  
7.     int left,right;  
8.     int n;  
9. }a[30000];  
10.   
11. void buildt(int l,int r,int step){  
12.     a[step].left=l;  
13.     a[step].right=r;  
14.     a[step].n=0;  
15.     if(l==r) return;  
16.     buildt(l,(l+r)/2,step*2);  
17.     buildt((l+r)/2+1,r,step*2+1);  
18. }  
19.   
20. void dfs(int step){  
21.     cout<<step<<"    "<<a[step].left<<"    "<<a[step].right<<"    "<<a[step].n<<endl;  
22.     if(a[step].left==a[step].right) return;  
23.     dfs(step*2);  
24.     dfs(step*2+1);  
25. }  
26.   
27. void insert(int s,int t,int step){  
28.     if(s==a[step].left&&t==a[step].right){  
29.         a[step].n++;  
30.         return;  
31.     }  
32.     if(a[step].left==a[step].right) return;  
33.     int mid=(a[step].left+a[step].right)/2;  
34.     if(mid>=t) insert(s,t,step*2);  
35.     else if(mid<s) insert(s,t,step*2+1);  
36.     else{  
37.         insert(s,mid,step*2);  
38.         insert(mid+1,t,step*2+1);  
39.     }  
40. }  
41.   
42. int main(){  
43.     cin>>n>>m;  
44.     buildt(0,n,1);  
45.     //dfs(1);  
46.     for(int i=0;i<m;i++){  
47.         cin>>l>>r;  
48.         insert(l,r,1);  
49.     }  
50.     dfs(1);  
51.     return 0;  
52. }  

个人模板：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cstring>
#include<cmath>
using namespace std;
int n,m,l,r;
int sum=0;
struct line{
	int l,r,n;
}segtree[3000];
void build(int s,int e,int node)
{
	segtree[node].l=s;
	segtree[node].r=e;
	segtree[node].n=0;
	if(s==e)
		return;
	int mid=(s+e)/2;
	build(s,mid,2*node);
	build(mid+1,e,2*node+1);
}
void insert(int s,int e,int node)
{
	if(s==segtree[node].l&&e==segtree[node].r)
	{
		segtree[node].n++;
		return;
	}
	if(segtree[node].l==segtree[node].r)
		return;
	int mid=(segtree[node].l+segtree[node].r)/2;
	if(e<=mid)
		insert(s,e,node*2);
	else if(s>mid)
		insert(s,e,node*2+1);
	else
	{
		insert(s,mid,node*2);
		insert(mid+1,e,node*2+1);
	}
}
void dfs(int node)
{
	cout<<node<<"   "<<segtree[node].l<<"   "<<segtree[node].r<<"   "<<segtree[node].n<<endl;
	if(segtree[node].l==segtree[node].r)
		return;
	dfs(node*2);
	dfs(node*2+1);
}
void count(int s,int e,int node)
{
	if(segtree[node].l==segtree[node].r)
		return;
	sum+=segtree[node].n;
	int mid=(segtree[node].l+segtree[node].r)/2;
	if(mid>=e)
		count(s,e,node*2);
	else if(mid<s)
		count(s,e,node*2+1);
	else
	{
		count(s,mid,node*2);
		count(mid+1,e,node*2+1);
	}
}
int main()
{
	int a,b;
	cin>>n>>m;
	build(0,n,1);
	for(int i=1;i<=m;i++)
	{
		cin>>l>>r;
		insert(l,r,1);
	}
	dfs(1);
	while(1)
	{sum=0;
	scanf("%d%d",&a,&b);
	count(a,b,1);
	printf("%d\n",sum);
	}
	return 0;
}