士兵杀敌（四） 线段树



描述

南将军麾下有百万精兵，现已知共有M个士兵，编号为1~M，每次有任务的时候，总会有一批编号连在一起人请战（编号相近的人经常在一块，相互之间比较熟悉），最终他们获得的军功，也将会平分到每个人身上，这样，有时候，计算他们中的哪一个人到底有多少军功就是一个比较困难的事情，军师小工的任务就是在南将军询问他某个人的军功的时候，快速的报出此人的军功，请你编写一个程序来帮助小工吧。

假设起始时所有人的军功都是0.

输入

只有一组测试数据。
每一行是两个整数T和M表示共有T条指令，M个士兵。（1<=T,M<=1000000)
随后的T行，每行是一个指令。
指令分为两种：
一种形如
ADD 100 500 55 表示，第100个人到第500个人请战，最终每人平均获得了55军功，每次每人获得的军功数不会超过100，不会低于-100。
第二种形如：
QUERY 300 表示南将军在询问第300个人的军功是多少。

输出

对于每次查询输出此人的军功，每个查询的输出占一行。

样例输入

4 10ADD 1 3 10QUERY 3ADD 2 6 50QUERY 3

样例输出

1060

第一次用线段树

在自然数，且所有的数不大于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倍；

  #include <iostream>#include <algorithm>#include <queue>#include <math.h>#include <deque>#include <stack>#include <set>#include <limits>#include <string.h>#include <stdio.h>#include <stdlib.h>#define ll long long#define MAX 100005#define root 1,m,1#define lson l,mid,rt << 1#define rson mid+1,r,rt << 1 | 1using namespace std;struct node{    int Left,Right;    int n;}a[5000010];int ans;void buildt(int l,int r,int step){    a[step].Left=l;    a[step].Right=r;    a[step].n=0;    if(l==r)        return ;    int mid=(l+r)/2;    buildt(l,mid,step*2);    buildt(mid+1,r,step*2+1);}void Insert(int s,int t,int num,int step){    if(s <= a[step].Left  && t >= a[step].Right )        {            a[step].n+=num;            return ;        }        if(a[step].Left == a[step].Right)            return ;        int mid=(a[step].Left + a[step].Right)/2;        if(mid >= t)            Insert(s,t,num,step*2);        if(mid < s)        Insert(s,t,num,step*2+1);        if(s<= mid  && mid < t)        {            Insert(s,mid,num,step*2);            Insert(mid,t,num,step*2+1);        }}void query(int rt,int q){    if(a[rt].Left <= q  && q <= a[rt].Right)    ans+=a[rt].n;    if(a[rt].Left == a[rt].Right)        return ;    int mid=(a[rt].Left + a[rt].Right )/2;    if(q <= mid)        query(2*rt,q);    if(q > mid)        query(2*rt  | 1,q);}int main(){//    int b=4 | 1;//    cout<<b<<endl;    int n,m,aa,b,c,q;    char str[10];    scanf("%d%d",&n,&m);    buildt(root);    while(n--)    {        scanf("%s",str);        if(strcmp(str,"ADD")==0)        {            scanf("%d %d %d",&aa,&b,&c);            Insert(aa,b,c,1);        }        else        {            scanf("%d",&q);            ans=0;            query(1,q);            printf("%d\n",ans);        }    }    return 0;}