树状数组

问题 A: 敌兵布阵

时间限制: 2 Sec 内存限制: 10000 MB
题目描述
C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手但这些都逃不过C国的监视。
中央情报局要研究敌人究竟演习什么战术所以Tidy要随时向Derek汇报某一段连续的工兵营地一共有多少人例如Derek问:“Tidy马上汇报第3个营地到第10个营地共有多少人!”Tidy就要马上开始计算这一段的总人数并汇报。但敌兵营地的人数经常变动，而Derek每次询问的段都不一样，所以Tidy不得不每次都一个一个营地的去数，很快就精疲力尽了，Derek对Tidy的计算速度越来越不满:"你个死肥仔，算得这么慢，我炒你鱿鱼!”Tidy想：“你自己来算算看，这可真是一项累人的工作!我恨不得你炒我鱿鱼呢!”无奈之下，Tidy只好打电话向计算机专家Windbreaker求救Windbreaker说：“死肥仔，叫你平时做多点acm题和看多点算法书，现在尝到苦果了吧!”Tidy说："我知错了。。。"但Windbreaker已经挂掉电话了。Tidy很苦恼，这么算他真的会崩溃的，聪明的读者，你能写个程序帮他完成这项工作吗？不过如果你的程序效率不够高的话，Tidy还是会受到Derek的责骂的.
输入
第一行一个整数T，表示有T组数据。
每组数据第一行一个正整数N（N<=50000）表示敌人有N个工兵营地，接下来有N个正整数第i个正整数ai代表第i个工兵营地里开始时有ai个人（1<=ai<=109）。
接下来每行有一条命令，命令有4种形式：
(1) Add i ji和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条命令
输出
对第i组数据首先输出“Case i:”和回车
对于每个Query询问，输出一个整数并回车表示询问的段中的总人数这个数保持在int以内。
样例输入
1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End
样例输出
Case 1:
6
33
59

                          单点更新，区间查询
#include<bits/stdc++.h>
using namespace std;
const int maxn=50000;
int n,m;
int tree[maxn];

int lowbit(int x){
  return x&(-x);
}

void update(int i,int x){
  for(int j=i;j<=n;j+=lowbit(j)){
     tree[j]+=x;
  }
}

long long getsum(int i){
  long long sum=0;
   for(int j=i;j>=1;j-=lowbit(j))
      sum+=tree[j];
  return sum;
}

int main(){
  int t,x,y;
  string czzl;
  cin>>t;
  for(int l=1;l<=t;l++){
      cin>>n;
      printf("Case %d:\n",l);
      memset(tree, 0, sizeof tree);
      int num;
      for(int i=1;i<=n;i++){
         cin>>num;
         update(i,num);
      }
        while(cin>>czzl){
              if(czzl=="Add"){
                  cin>>x>>y;
                  update(x,y);
              }else if(czzl=="Sub"){
                  cin>>x>>y;
                  update(x,-y);
              }else if(czzl=="Query"){
                  cin>>x>>y;
                  cout<<getsum(y)-getsum(x-1)<<endl;
              }else break;
      }
  }
  return 0;
}

问题 B: 红红数星星

时间限制: 1 Sec 内存限制: 128 MB
题目描述
学霸红红不但基础课学得好，敲代码敲得好，还有一个就是他喜欢夜观天象，和古代张衡不同的是，红红观测星星都喜欢将他们放在笛卡尔坐标系内观测。有一天红红和未来的大数学家可可一起夜观天象，红红用一张纸将他观测的所有星星都画在了同一二维直角坐标系内，他定义一颗星星左下方星星的数量为该星星的等级，现在他问可可给定星图上每个等级的星星数量。

例如，查看上图所示的地图，5号星的等级为3(左下方有1、2、4号星)，2号星和4号星的等级为1。在这张地图上有一颗0级的星星，两颗1级的星星，一颗2级的星星，和一颗3级的星星。
输入
输入的第一行包括了星星的数量N (1 ≤ N ≤ 15000)，下面N行描述了每颗星星的坐标(每一行由一个空格分隔两个整数X和Y组成 0 ≤ XY ≤ 32000)。每一个点只会存在一颗星星。星星以Y坐标的升序排列。Y坐标相等的恒星按X坐标的升序排列。
输出
输出应该包括N行，每行一个数字。第 i 行是等级为 i - 1的星星的数量( 1 ≤ i ≤ n )。
样例输入
7
1 1
5 1
7 1
3 3
5 5
5 6
7 8
样例输出
1
2
1
1
1
0
1

方法一：朴素算法（时间长）
因为他的y坐标是按升序排列的所以你在统计的时候不必考虑纵坐标，就是你后面输入的纵坐标一定是大于等于你前面的坐标的，所以你只需统计x
#include<bits/stdc++.h>
using namespace std;
const int maxn=150000+5;
int level[maxn];
int xx[maxn];
int main(){
  int n,x,y,sum;
  cin>>n;
  for(int j=0;j<n;j++){
       cin>>x>>y;
       sum=0;
       for(int i=0;i<=x;i++)
            sum+=xx[i];       //因为统计的是之前的，所以先统计再把这个星星加进去
        level[sum]++;       //为这个等级的+1
        xx[x]++;           //再加这个星星
  }
    for(int i=0;i<n;i++)
        cout<<level[i]<<endl;
}


方法二：树状数组
利用上面的思想然后用树状数组做就行
是个单点更新，区间求和  不过是先查询后更新
#include<bits/stdc++.h>
using namespace std;
const int maxn=32000+5;
int tree[maxn],ans[maxn];
int n;
int lowbit(int x){
    return x&(-x);
}

void Update(int i,int num){
   for(int j=i;j<=maxn;j+=lowbit(j)){
     tree[j]+=num;
   }
}

int getsum(int i){
  int sum=0;
  for(int j=i;j>=1;j-=lowbit(j)){
    sum+=tree[j];
  }
  return sum;
}

int main(){
  int n,x,y;
  cin>>n;
  for(int i=0;i<n;i++){
      cin>>x>>y;
      x++;//加入x+1，是为了避免0，X是可能为0的   建树的时候是从1开始的
      ans[getsum(x)]++;
      Update(x,1);
  }
  for(int i=0;i<n;i++){
        cout<<ans[i]<<endl;
  }
}

问题 C: 红红的气球

时间限制: 1 Sec 内存限制: 128 MB
题目描述
小学生红红有N个气球排成一排，从左到右依次编号为123…N.每次给定2个整数a b(a <= b)调皮的红红想拥有很多种不同颜色的气球，于是他从气球a开始到气球b依次给每个气球涂一次颜色。但是N次以后红红已经忘记了第I个气球已经涂过几次颜色了，你能帮他算出每个气球被涂过几次颜色吗？

输入
每个测试实例第一行为一个整数N(N <= 100000).接下来的N行，每行包括2个整数a b(1 <= a <= b <= N)。
当N = 0，输入结束。

输出
每个测试实例输出一行，包括N个整数，第I个数代表第I个气球总共被涂色的次数。

样例输入
3
1 1
2 2
3 3
3
1 1
1 2
1 3
0
样例输出
1 1 1
3 2 1

区间更新，单点查询，利用的是差分 
#include<bits/stdc++.h>
using namespace std;
const int maxn= 100000+5;
int tree[maxn];
int a[maxn];
int n;
int lowbit(int x){
  return x&(-x);
}

void update(int i,int num){
   for(int j=i;j<=n;j+=lowbit(j)){
      tree[j]+=num;
   }
}

int getsum(int x){
  int sum=0;
  for(int i=x;i>=1;i-=lowbit(i))
    sum+=tree[i];
     return sum;
}

int main(){
   int a,b;
  while(cin>>n){
    memset(tree,0,sizeof(tree));
        if(n==0) break;
        //因为初始为就需要为0，所以不需要初始单点更新
        for(int i=1;i<=n;i++){    //区间更新
          cin>>a>>b;
          update(a,1);
          update(b+1,-1);
        }
        for(int i=1;i<=n;i++){
          cout<<getsum(i)<<" ";
        }
        cout<<endl;
  }
}

A Simple Problem with Integers
Time Limit: 5000MS Memory Limit: 131072K
Total Submissions: 169479 Accepted: 52237
Case Time Limit: 2000MS
Description
You have N integers, A1, A2, … , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.
Input
The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A1, A2, … , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
“C a b c” means adding c to each of Aa, Aa+1, … , Ab. -10000 ≤ c ≤ 10000.
“Q a b” means querying the sum of Aa, Aa+1, … , Ab.
Output
You need to answer all Q commands in order. One answer in a line.

Sample Input
10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

Sample Output
4
55
9
15

Hint
The sums may exceed the range of 32-bit integers.

区间更新，区间查询
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1e5+7;
LL tree1[maxn],tree2[maxn];
int n,q;
int a[maxn];

int lowbit(int x){
   return x&(-x);
}

void update(int i,LL x){
   for(int j=i;j<=n;j+=lowbit(j)){
        tree1[j]+=x;
        tree2[j]+=(i-1)*x;
   }
}

LL getsum(int i){
  LL ans=0;
   for(int j=i;j>=1;j-=lowbit(j)){
     ans+=i*tree1[j]-tree2[j];
   }
   return ans;
}


int main(){
   cin>>n>>q;
   char czzl;
   int x,y,add;
   for(int i=1;i<=n;i++){
       cin>>a[i];
       update(i,a[i]-a[i-1]);
   }
   for(int i=1;i<=q;i++){
     cin>>czzl;
     if(czzl=='C'){
        cin>>x>>y>>add;
        update(x,add);
        update(y+1,-add);
     }else{
        cin>>x>>y;
        cout<<getsum(y)-getsum(x-1)<<endl;;
     }
   }
}