南阳116士兵杀敌（二）（线段树）

士兵杀敌（二）

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 5

描述

南将军手下有N个士兵，分别编号1到N，这些士兵的杀敌数都是已知的。

小工是南将军手下的军师，南将军经常想知道第m号到第n号士兵的总杀敌数，请你帮助小工来回答南将军吧。

南将军的某次询问之后士兵i可能又杀敌q人，之后南将军再询问的时候，需要考虑到新增的杀敌数。

输入

只有一组测试数据
第一行是两个整数N,M，其中N表示士兵的个数(1<N<1000000)，M表示指令的条数。(1<M<100000)
随后的一行是N个整数，ai表示第i号士兵杀敌数目。(0<=ai<=100)
随后的M行每行是一条指令，这条指令包含了一个字符串和两个整数，首先是一个字符串，如果是字符串QUERY则表示南将军进行了查询操作，后面的两个整数m,n，表示查询的起始与终止士兵编号；如果是字符串ADD则后面跟的两个整数I,A(1<=I<=N,1<=A<=100),表示第I个士兵新增杀敌数为A.

输出

对于每次查询，输出一个整数R表示第m号士兵到第n号士兵的总杀敌数，每组输出占一行

样例输入

5 6
1 2 3 4 5
QUERY 1 3
ADD 1 2
QUERY 1 3
ADD 2 3
QUERY 1 2
QUERY 1 5

样例输出

6
8
8
20

线段树，区间求和，单点更新；还可以用树状数组；

线段树：

#include<stdio.h>
#include<string.h>
int u,m;
int sum;
struct node{
	int left;
	int right;
	int sum;
	int mid(){
		return (left+right)>>1;
	}
}s[4000400];
void btree(int left,int right,int n){
	s[n].left=left;
	s[n].right=right;
	if(left==right){
		scanf("%d",&s[n].sum);
		return;
	}
	int mid=s[n].mid();
	btree(left,mid,n<<1);
	btree(mid+1,right,(n<<1)+1);
	s[n].sum+=s[n<<1].sum+s[(n<<1)+1].sum;
}
void query(int left,int right,int n,int k,int l){
	if(left>=k&&right<=l){
		sum+=s[n].sum;
		return;
	}
	int mid=s[n].mid();
	if(mid>=l){
		query(left,mid,n<<1,k,l);
	}
	else if(mid<k){
		query(mid+1,right,(n<<1)+1,k,l);
	}
	else{
		query(left,mid,n<<1,k,l);
		query(mid+1,right,(n<<1)+1,k,l);
	}
}
void add(int left,int right,int n,int k,int l){
	if(left==right&&left==k){
		s[n].sum+=l;
		return;
	}
	int mid=s[n].mid();
	if(mid<k){
		add(mid+1,right,(n<<1)+1,k,l);
	}
	else{
		add(left,mid,n<<1,k,l);
	}
	s[n].sum=s[n<<1].sum+s[(n<<1)+1].sum;
}
int main(){
	while(~scanf("%d %d",&u,&m)){
		int i,j,k,l;
		char a[10];
		memset(s,0,sizeof(s));
		btree(1,u,1);
		//for(i=1;i<=u;i++){
		//	printf("%d\n",s[i].sum);
		//}
		while(m--){
		scanf("%s %d %d",a,&k,&l);
		//printf("%s %d %d\n",a,k,l);
		sum=0;//printf("righ2\n");
		if(a[0]=='Q'){
			query(1,u,1,k,l);
			printf("%d\n",sum);
		}
		else{
			add(1,u,1,k,l);
		}
		}
	}
	return 0;
}
树状数组：

#include<stdio.h>
#include<string.h>
int u,m;
long long c[1000100];
int lowbit(int i){
	return i&(-i);
}
void update(int i,int k){
	while(i<=u){
		c[i]+=k;
		i+=lowbit(i);
	}
}
long long getsum(int i){
	long long sum=0;
	while(i>=1){
		sum+=c[i];
		i-=lowbit(i);
	}
	return sum;
}
int main(){
	while(~scanf("%d %d",&u,&m)){
		int i,j,k,l;
		char a[10];
		memset(c,0,sizeof(c));
		for(i=1;i<=u;i++){
			scanf("%d",&k);
			update(i,k);
		} 
		//for(i=1;i<=u;i++){
		//	printf("%d\n",s[i].sum);
		//}
		while(m--){
		scanf("%s %d %d",a,&k,&l);
		//printf("%s %d %d\n",a,k,l);
		if(a[0]=='Q'){
			
			printf("%lld\n",getsum(l)-getsum(k-1));
		}
		else{
			update(k,l);
		}
		}
	}
	return 0;
}
关于树状数组的一些知识:

转载

如果给定一个数组，要你求里面所有数的和，一般都会想到累加。但是当那个数组很大的时候，累加就显得太耗时了，时间复杂度为O(n)，并且采用累加的方法还有一个局限，那就是，当修改掉数组中的元素后，仍然要你求数组中某段元素的和，就显得麻烦了。所以我们就要用到树状数组，他的时间复杂度为O（lgn），相比之下就快得多。下面就讲一下什么是树状数组：
         一般讲到树状数组都会少不了下面这个图：
         
         下面来分析一下上面那个图看能得出什么规律：
         据图可知：c1=a1，c2=a1+a2，c3=a3，c4=a1+a2+a3+a4，c5=a5，c6=a5+a6，c7=a7，c8=a1+a2+a3+a4+a5+a6+a7+a8，c9=a9，c10=a9+a10，c11=a11........c16=a1+a2+a3+a4+a5+.......+a16。
         分析上面的几组式子可知，当 i 为奇数时，ci=ai ；当 i 为偶数时，就要看 i 的因子中最多有二的多少次幂，例如，6 的因子中有 2 的一次幂，等于 2 ，所以 c6=a5+a6（由六向前数两个数的和），4 的因子中有 2 的两次幂，等于 4 ，所以 c4=a1+a2+a3+a4（由四向前数四个数的和）。
        （一）有公式：cn=a(n-a^k+1)+.........+an（其中 k 为 n 的二进制表示中从右往左数的 0 的个数）。
         那么，如何求 a^k 呢？求法如下：
     
     

      
      

       
       
 
           
 
            
 
             int  
             lowbit( 
             int  
             x) 
            
 
            
 
             { 
            
 
            
 
                   
             return  
             x&(-x);     
            
 
            
 
             } 
            
 
           
      
      
     
     
         lowbit（）的返回值就是 2^k 次方的值。
         求出来 2^k 之后，数组 c 的值就都出来了，接下来我们要求数组中所有元素的和。
         （二）求数组的和的算法如下：
         （1）首先，令sum=0，转向第二步；
         （2）接下来判断，如果 n>0 的话，就令sum=sum+cn转向第三步，否则的话，终止算法，返回 sum 的值；
         （3）n=n - lowbit（n）（将n的二进制表示的最后一个零删掉），回第二步。
          代码实现：
     
     

      
      

       
       
 
           
 
            
 
             int  
             Sum( 
             int  
             n) 
            
 
            
 
             { 
            
 
            
 
                  
             int  
             sum=0; 
            
 
            
 
                  
             while 
             (n>0) 
            
 
            
 
                  
             { 
            
 
            
 
                       
             sum+=c[n]; 
            
 
            
 
                       
             n=n-lowbit(n); 
            
 
            
 
                  
             }     
            
 
            
 
                  
             return  
             sum; 
            
 
            
 
             } 
            
 
           
      
      
     
     
         （三）当数组中的元素有变更时，树状数组就发挥它的优势了，算法如下（修改为给某个节点 i 加上 x ）：
         （1）当 i<=n 时，执行下一步；否则的话，算法结束;
         （2）ci=ci+x ，i=i+lowbit（i）（在 i 的二进制表示的最后加零），返回第一步。
          代码实现：
     
     

      
      

       
       
 
           
 
            
 
             void  
             change( 
             int  
             i, 
             int  
             x) 
            
 
            
 
             { 
            
 
            
 
                   
             while 
             (i<=n) 
            
 
            
 
                   
             { 
            
 
            
 
                        
             c[i]=c[i]+x; 
            
 
            
 
                        
             i=i+lowbit(i); 
            
 
            
 
                   
             } 
            
 
            
 
             }