題目大意：
第一行一個整數T，表示有T組資料。
每組資料第一行一個正整數N（N<=50000）,表示敵人有N個工兵營地，接下來有N個正整數,第i個正整數ai代表第i個工兵營地裡開始時有ai個人（1<=ai<=50）。
接下來每行有一條命令，命令有4種形式：
(1) Add i j,i和j為正整數,表示第i個營地增加j個人（j不超過30）
(2)Sub i j ,i和j為正整數,表示第i個營地減少j個人（j不超過30）;
(3)Query i j ,i和j為正整數,i<=j，表示詢問第i到第j個營地的總人數;
(4)End 表示結束，這條命令在每組資料最後出現;
每組資料最多有40000條命令

樹狀陣列：

#include<iostream>
#include<stdio.h>
#include<string.h>
#define LL long long
using namespace std;
long long delta[50010];  
long long sum[50010];  
int n,q;
int lowbit(int x){
    return x&(-x);
}
void update(LL *array,int pos,int d){
    while(pos<=n){
        array[pos]+=d;
        pos+=lowbit(pos);
    }
}
LL query(LL *array
 
,int pos){
    LL ans=0;
    while(pos>0){
        ans+=array[pos];
        pos-=lowbit(pos);
    }
    return ans;
}
int main(){
    int num[50010];
    int T;
    cin>>T;
    int i=1;
    while(T--){
        cout<<"Case "<<i++<<":"<<endl;
        cin>>n;
        memset
 
(delta,0,sizeof(delta));
        sum[0]=0;
        int i,j,k;
        for(i=1;i<=n;i++){      
            scanf("%d",&num[i]);
            sum[i]=sum[i-1]+num[i];         
        }
        char str[8];
        while(scanf("%s",str)!=EOF){
            int a,b;
            if(str[0]=='E') break;
            scanf("%d%d",&a,&b);
            if(str[0]=='Q'){
                int ans=0;
                ans+=sum[b]-sum[a-1];
                ans+=query(delta,b)-query(delta,a-1);
                cout<<ans<<endl;
            }
            if(str[0]=='A'){
                update(delta,a,b);
            }
            if(str[0]=='S'){
                update(delta,a,-b);
            }
        }
    }
    return 0;
}

這道題其實不用這樣寫，這種寫法與poj3468的樹狀陣列寫法有點相似。

線段樹：

#include<iostream>
#include<string.h>
#include<stdio.h>
using namespace std;
#define MAXN 50015
int num[MAXN];
struct TREE{
    int left,right;
    int sum;
}t[4*MAXN];
void buildtree(int root,int left,int right){
    t[root].right=right;
    t[root].left=left;
    t[root].sum=0;
    if(left==right){
        t[root].sum=num[left];
        return;
    }
    int mid=(left+right)/2;
    buildtree(root*2,left,mid);
    buildtree(root*2+1,mid+1,right);
    t[root].sum=t[root*2].sum+t[root*2+1].sum;
}
int query(int root,int begin,int end){
    if(t[root].left==begin&&t[root].right==end)   
        return t[root].sum;
    int mid=(t[root].left+t[root].right)/2;
    if(end<=mid)
        return query(2*root,begin,end);
    else if(begin>mid)
        return query(2*root+1,begin,end);
    else return query(2*root,begin,mid)+query(2*root+1,mid+1,end);
}

void update(int root,int pos,int value){
    if(t[root].right==t[root].left&&t[root].left==pos){  //right==left==pos
            t[root].sum+=value;
            return;
    }
    int mid=(t[root].right+t[root].left)/2;
    if(pos<=mid)
        update(root*2,pos,value);
    else update(root*2+1,pos,value);
    t[root].sum=t[root*2].sum+t[root*2+1].sum;
}
int main(){
    int t,n,i;
    int cnt=1;
    scanf("%d",&t);
    while(t--){
        printf("Case %d:\n",cnt++);
        scanf("%d",&n);
        for(i=1;i<=n;i++)          //因為結構體是從1開始存的，所以這裡為了方便也從1開始存 
            scanf("%d",&num[i]);
        buildtree(1,1,n);
        char s[8];
        while(scanf("%s",s)!=EOF){
            if(s[0]=='E') break;
            int a,b;
            scanf("%d%d",&a,&b);
            if(s[0]=='Q'){
                int ans=query(1,a,b);
                printf("%d\n",ans); 
            }           
            if(s[0]=='A'){
                update(1,a,b);
            }
            if(s[0]=='S'){
                update(1,a,-b);
            }           
        }
    }
    return 0;
}

題目大意：
n個整數，兩種操作：詢問a-b的區間和；將a-b的每個數加上一個數c。對於詢問輸出和。

樹狀陣列寫法：

#include<iostream>
#include<stdio.h>
#include<string.h>
#define LL long long
using namespace std;
/* 設delta[i]表示[i,n]的公共增量 */
long long c1[100010];   /* 維護delta[i]的字首和 */
long long sum[100010];  
long long c2[100010];   /* 維護delta[i]*i的字首和 */
int n,q;

int lowbit(int x){
    return x&(-x);
}
void update(LL *array,int be,int d){
    while(be<=n){
        array[be]+=d;
        be+=lowbit(be);
    }
}
LL query(LL *array,int pos){
    LL ans=0;
    while(pos>0){
        ans+=array[pos];
        pos-=lowbit(pos);
    }
    return ans;
}
int main(){
    int num[100010];
    while(cin>>n>>q){
        memset(c1,0,sizeof(c1));
        memset(c2,0,sizeof(c2));
        sum[0]=0;
        int i,j,k;
        for(i=1;i<=n;i++){      
            scanf("%d",&num[i]);
            sum[i]=sum[i-1]+num[i];         
        }
        char ch;
        while(q--){
            getchar();
            scanf("%c",&ch);
            if(ch=='Q'){
                int a,b;
                LL ans=0;
                scanf("%d%d",&a,&b);
                ans=sum[b]-sum[a-1];
                ans+=(b+1)*query(c1,b)-query(c2,b);  //1-b的剩下兩部分的和       
                ans-=(a)*query(c1,a-1)-query(c2,a-1); //1-a-1的剩下兩部分的和               
                printf("%lld\n",ans);

            }
            if(ch=='C'){
                int a,b,d;
                scanf("%d%d%d",&a,&b,&d);
                update(c1,a,d);
                update(c1,b+1,-d);
                update(c2,a,a*d);
                update(c2,b+1,-d*(b+1));
            }
        }
    }
    return 0;
}

線段樹：

#include<iostream>
#include<stdio.h>
#define MAXN 100000
#define LL long long
using namespace std;
struct TREE{
    int l,r;
    LL sum;
    LL d;    //表示對某個父節點其對應的區間裡的變化量 
}t[4*MAXN+10];
LL num[MAXN+5];

//建樹 
void buildtree(LL k,LL l,LL r){
    t[k].l=l;t[k].r=r;t[k].sum=0;t[k].d=0;
    if(r==l){
        t[k].sum=num[l];   //注意是num[l]或num[r]  而不是num[k] 
        return;
    }
    LL mid=(l+r)/2;
    buildtree(k*2,l,mid);
    buildtree(2*k+1,mid+1,r);
    t[k].sum=t[k*2].sum+t[k*2+1].sum;
}

//詢問 
LL queryL(LL k,LL l,LL r){  
    if(t[k].l==l&&t[k].r==r){   //如果剛好是想要的區間 
        return t[k].sum;        //@@@語句（自己標註的，下文有用） 
    }

    //此步不能省！如果出現讓1-9每個都加3，然後詢問1-5區間和的情況，不寫會錯。
    //要保證與查詢區間相連並且在其上方的節點的d值全部為0，即這些節點全部被拆分完成，才能求出正確的和 
    if(t[k].d){                 //如果這個點對應的區間有改變數，且不是詢問的區間 
        t[2*k].d+=t[k].d;       //其子節點繼承這個區間的增量（換言之，區間拆分） 
        t[2*k].sum+=(t[2*k].r-t[2*k].l+1)*t[k].d;   //改變和 
        t[2*k+1].d+=t[k].d;
        t[2*k+1].sum+=(t[2*k+1].r-t[2*k+1].l+1)*t[k].d;
        t[k].d=0;               //由於這個區間的改變數已經計算在其子節點的sum裡，因此將其歸零 
    }


    LL ans=0;                   //遞迴函式內定義的ans，每次呼叫的函式裡面的ans都是不相同的 
    LL mid=(t[k].l+t[k].r)/2;    
    if(r<=mid) ans+=queryL(2*k,l,r);
    else if(l>mid) ans+=queryL(2*k+1,l,r);
    else {
    ans+=queryL(2*k,l,mid);
    ans+=queryL(2*k+1,mid+1,r);
    }
    return ans;
}

//更新 
void update1(LL k,LL l,LL r,LL d){
    if(t[k].l==l&&t[k].r==r){
        t[k].d+=d;      //注意是+=  而不是=  
        t[k].sum+=(t[k].r-t[k].l+1)*d;  //!!!語句 
        return;
    }
    if(t[k].l==t[k].r) return;


    //這一步也必須地寫，即每改變一次都要更新一次。
    //如果不寫，可以理解為把所有的變化量都記錄下來，等到詢問的時候再一次更新,顯然這樣有問題：
    //比如1-5區間有一個直接的增加3(即update(1,5,3)),還有一個從1-10那裡繼承來的增加6(即update(1,10,6)),
    //如果不每次更新的話,顯然對於1-5區間,有update(1,5,9) .因此對於1-5區間對應的節點sum值增加了45.
    //然而對於直接增加3，1-5區間已經增加了5*3=15(見!!!語句) 增加45現在多增加了。

    //那麼，如果把!!!語句去掉不就不會多加了嗎？
    //如果這裡去掉，那麼碰到要找的區間就不會加上它自身的改變值了（另修改程式碼單論）,見@@@語句，即t[1~5].d==9,當查詢1-5時直接返回以前的sum值了

    //那麼，如果不去掉!!!語句，再其後加上一個t[k].d=0,不就既不會多加也不會少算了嗎？(即把直接的update加完後d歸零)
    //這樣就有了一個新的問題，如果再求1-2的區間和，就算不上1-5的增加3了。 

    //因此，這裡的if(t[k].d){...}不能省，如果要省必須大幅度修改程式碼，還是算了吧。  
    if(t[k].d){
        t[2*k].d+=t[k].d;
        t[2*k].sum+=t[k].d*(t[2*k].r-t[2*k].l+1);
        t[2*k+1].d+=t[k].d;
        t[2*k+1].sum+=t[k].d*(t[2*k+1].r-t[2*k+1].l+1);
        t[k].d=0;   //注意這步，如果改變數已經被拆分過了，就歸零了。因此不會出現多加的情況。 
    }

    LL mid=(t[k].l+t[k].r)/2;   
    if(r<=mid) update1(2*k,l,r,d);
    else if(l>mid) update1(2*k+1,l,r,d);
    else {
        update1(2*k,l,mid,d);
        update1(2*k+1,mid+1,r,d);
    }
    t[k].sum=t[2*k].sum+t[2*k+1].sum;  //更新父節點的和 
}

int main(){
    LL n,m;
    scanf("%lld%lld",&n,&m);
    for(LL i=1;i<=n;i++)
        scanf("%lld",&num[i]);
    buildtree(1,1,n);      //今天，你寫這句話了嗎？ 日常忘記主函式建樹，日常作死。
    char ch;
    while(m--){
        getchar();
        scanf("%c",&ch);
        LL a,b,d;
        scanf("%lld%lld",&a,&b);
        if(ch=='Q'){
            printf("%lld\n",queryL(1,a,b));
        }
        else scanf("%lld",&d);
        if(ch=='C'){
            update1(1,a,b,d);           
        }
    }
    return 0;
}

思考關於 if (t[k].d) {….}能不能省的問題思考了一下午，初學線段樹感覺心態爆炸，所以提醒自己以後如果碰到類似複雜的是否可以簡化更新的問題的話，不要為了省執行時間、少寫程式碼而不去更新，很容易錯。更新也不見得超時，超了時的話再回來思考哪裡的更新可以省略才是正解~~
如果有理解不對的地方還請多多指教~~