南将军麾下有百万精兵,现已知共有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 10 ADD 1 3 10 QUERY 3 ADD 2 6 50 QUERY 3
样例输出
-
10 60
-
第一次用线段树
在自然数,且所有的数不大于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 | 1 using 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; }