hdu1394 这题说的是给了一个序列计算这个序列的逆序对总共要进行n次 每次都将目前的第一个放到序列的最后一个位置然后 计算一次逆序对 这样我们只需要先求一次逆序对 然后接着每次都用F=F+(n-T[i]-1)+T[i]  求得下一个 就不需要每次都去算逆序对

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <string.h>
  4. using namespace std;
  5. const int maxn = ;
  6. int C[];
  7. int T[];
  8. int n;
  9. int lowbit(int x){
  10.     return x&(-x);
  11. }
  12. int sum(int x){
  13.     int ret = ;
  14.     while(x>){
  15.          ret+=C[x]; x-=lowbit(x);
  16.     }
  17.     return ret;
  18. }
  19. void add(int x,int d){
  20.     while(x<=n){
  21.         C[x]+=d; x+=lowbit(x);
  22.     }
  23. }
  24. int Fenwick(int st){
  25.        int ans =;
  26.        for(int i = ;i<n ;++ i){
  27.             add(T[(st+i)%n],);
  28.             int S1=sum(n);
  29.             int S2 =sum(T[(st+i)%n]);
  30.             ans+=S1-S2;
  31.        }
  32.        return ans;
  33. }
  34. int main()
  35. {
  36.       while(scanf("%d",&n) == ){
  37.           int ans =0x7fffffff;
  38.           for(int i =  ; i< n ;++ i){
  39.                 scanf("%d",&T[i]);
  40.                 ++T[i];
  41.             }
  42.             memset(C,,sizeof(C));
  43.             int f=Fenwick();
  44.             for(int i= ; i<n ;++i){
  45.  
  46.                 f=f+n-T[i]-(T[i]-);
  47.                 ans =min(ans,f);
  48.             }
  49.           printf("%d\n",ans);
  50.       }
  51.       return ;
  52. }

acdream1127 这题说的是给了两个 大站点  在大站点的他们附近有许多的小站点 小站点只能通过大站点与外界通信 大站点有一个圆形的作用范围 这个范围内的点可以接受信息 范围外的不能好了就这样,这样他给了很多个不同的半径 计算在每个半径不同的情况下又多少个点不在范围内  因为有两个点所以 每个点就形成了与他们距离 的一个二维的相对坐标,当他不在第一个点的坐标内的时候我们可以将他 放进 第二维的树状数组中 通过求和判断是否在第二维的相应的坐标里这样我们 用 第二点的半径所在的位置去进行一次求和 和 总数n   sum(n)得到的是 目前不在 第一个范围内的点的个数sum(第二个半径的位置) 得到的是在第二个范围内点的个数 然后相减一下就得到了

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <string.h>
  4. #include <algorithm>
  5. using namespace std;
  6. const int maxn=;
  7. int C[maxn],N;
  8. struct node{
  9.    long long x,y;
  10.    int num;
  11.    bool operator <(const node &A)const {
  12.       return x>=A.x;
  13.    }
  14. }P[maxn],Query[maxn];
  15. long long dist[maxn];
  16. bool cmp1(node A,node B){
  17.    return A.x >= B.x ;
  18. }
  19. int lowbit(int x){
  20.    return x&(-x);
  21. }
  22. void add(int x,int d){
  23.       while(x<=N){
  24.          C[x]+=d; x+=lowbit(x);
  25.       }
  26. }
  27. int sum(int x){
  28.       int ans =;
  29.       while(x>){
  30.           ans+=C[x];
  31.           x-=lowbit(x);
  32.       }
  33.       return ans;
  34. }
  35. int ans[maxn];
  36. int main()
  37. {
  38.       long long x1,y1,x2,y2;
  39.       while(scanf("%I64d%I64d%I64d%I64d",&x1,&y1,&x2,&y2)==){
  40.            scanf("%d",&N);
  41.            for(int i = ; i<N; ++ i){
  42.                 long long x,y;
  43.                 scanf("%I64d%I64d",&x,&y);
  44.                 P[i].x=(x-x1)*(x-x1)+(y-y1)*(y-y1);
  45.                 P[i].y=(x-x2)*(x-x2)+(y-y2)*(y-y2);
  46.                 dist[i+]=P[i].y;
  47.            }
  48.            int M;
  49.            scanf("%d",&M);
  50.            for(int i = ; i<M; ++i){
  51.                 long long r1,r2;
  52.                 scanf("%I64d%I64d",&r1,&r2);
  53.                 Query[i].x=r1*r1;
  54.                 Query[i].y=r2*r2;
  55.                 Query[i].num=i;
  56.            }
  57.            sort(P,P+N,cmp1);
  58.            sort(dist+,dist++N);
  59.            int num=unique(dist+,dist++N)--dist;
  60.            sort(Query,Query+N,cmp1);
  61.            int id=;
  62.            memset(C,,sizeof(C));
  63.            for(int i =; i<M; ++ i) {
  64.                  while( id<N && P[id].x >= Query[i].x ) {
  65.                       int loc = lower_bound( dist + , dist++num, P[id].y )-dist;
  66.                       add(loc,);
  67.                       ++id;
  68.                  }
  69.                 int lox = lower_bound(dist + , dist++num, Query[i].y)-dist-;
  70.                 int SN =sum(N);
  71.                 int SLOX =sum(lox);
  72.                 ans[Query[i].num] = SN -SLOX;
  73.            }
  74.            for(int i =; i<M; ++i)
  75.             printf("%d\n",ans[i]);
  76.       }
  77.       return ;
  78. }

#247div2 E 题 这题说的是 有n个试管每个试管中有一些汞 然后又两种操作 第一种是将某个试管中的汞的体积变成 xi 然后将第二种操作是将 Vi 升的水倒入 这n个试管中求 有装水的试管中水的体积最大的 体积最小, 这样我们可以去二分找这个可能的高度 ,将所有可能的高度进行一次离散化,然后不断的用树状数组去修改和查询,然后得到了正解

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <string.h>
  4. #include <set>
  5. #include <map>
  6. using namespace std;
  7. const int maxn=;
  8. int h[maxn],T[],n,q,max_h=;
  9. int p[],x[],cap[maxn];
  10. __int64 V[];
  11. __int64 A[maxn],B[maxn];
  12. int lowbit(int x){
  13.   return x&(-x);
  14. }
  15. void add(__int64 *C, int x,__int64 d){
  16.       while(x<=max_h){
  17.          C[x]+=d; x+=lowbit(x);
  18.       }
  19. }
  20. __int64 sum(__int64 *C,int x){
  21.      __int64 ans=;
  22.      while(x>){
  23.          ans+=C[x]; x-=lowbit(x);
  24.      }
  25.      return ans;
  26. }
  27. __int64 solve(int H){
  28.     __int64 num=sum(A,H);
  29.     __int64 remain = sum(B,H);
  30.     __int64 line=cap[H];
  31.     __int64 ans = num * line - remain;
  32.     return ans;
  33. }
  34. int main()
  35. {
  36.        set<int>Live;
  37.        scanf("%d%d",&n,&q);
  38.        for(int i =; i<=n; ++i){
  39.           scanf("%d",&h[i]);
  40.           Live.insert(h[i]);
  41.        }
  42.  
  43.        for( int i =; i<q; ++i){
  44.           scanf("%d",&T[i]);
  45.           if(T[i] == ){
  46.              scanf("%d%d",&p[i],&x[i]);
  47.              Live.insert(x[i]);
  48.           }else scanf("%I64d",&V[i]);
  49.        }
  50.        map<int,int>MP;
  51.        for(set<int>::iterator it=Live.begin(); it!=Live.end(); ++it){
  52.            int E = *it;
  53.            MP.insert(make_pair(E,max_h+));
  54.            ++max_h;
  55.            cap[max_h] = E;
  56.        }
  57.        for(int i =; i<=n; ++i){
  58.           int loc = MP[h[i]];
  59.           add(A,loc,);
  60.           add(B,loc,h[i]);
  61.        }
  62.        for(int e=; e<q; ++e){
  63.            if(T[e]==){
  64.                 int t = p[e];
  65.                 int loc = MP[h[t]];
  66.                 add(A, loc, -);
  67.                 add(B, loc, -h[t]);
  68.                 h[t] = x[e];
  69.                 loc  = MP[h[t]];
  70.                 add(A, loc, );
  71.                 add(B, loc, h[t]);
  72.            }else{
  73.                 int H=;
  74.                 for(int i = ; i>=; -- i){
  75.                     if((H+(<<i))>max_h) continue;
  76.                     if(solve((H+(<<i)))<=V[e])
  77.                         H=H+(<<i);
  78.                 }
  79.                 double remain=solve(H);
  80.                 double num=sum(A,H);
  81.                 double ans = cap[H];
  82.                 ans =ans + (double(V[e]) - remain)/num;
  83.                 printf("%.5lf\n",ans);
  84.            }
  85.  
  86.        }
  87.        return ;
  88. }

uva1513 这 题 说 的 是 给 了 一 个 堆(从1...到n) 然 后 从 堆 中 的 某 个 位 置 取 一 个 点 出 来 放在最顶端 每次 操作时输出在该点的上方有多少个点用树状数组去查询 自然前面预留m个位置 可 以 放 后 面 堆 叠 的 在 前 面 的 然后每次操作记录一下该点所在的位置

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <string.h>
  4. using namespace std;
  5. const int maxn=;
  6. int n,m,local[maxn];
  7. int C[maxn*],ans[maxn];
  8. int lowbit(int x){
  9.   return x&(-x);
  10. }
  11. void add(int x,int d){
  12.      while(x<=n+m){
  13.         C[x]+=d;
  14.         x+=lowbit(x);
  15.      }
  16. }
  17. int sum(int x){
  18.     int ans=;
  19.     while(x>){
  20.         ans+=C[x];
  21.         x-=lowbit(x);
  22.     }
  23.     return ans;
  24. }
  25. int main()
  26. {
  27.     int cas;
  28.     scanf("%d",&cas);
  29.     while( cas -- ){
  30.          scanf("%d%d",&n,&m);
  31.        for(int i=;i<=n+m; ++i)C[i]=;
  32.        for(int i=; i<=n; ++i){
  33.             local[i]=i+m;
  34.             add(m+i,);
  35.        }
  36.        int len=;
  37.        for( int i=m; i> ; --i){
  38.             int a;
  39.             scanf("%d",&a);
  40.             ans[len++]=sum(local[a]-);
  41.             add(local[a],-);
  42.             local[a]=i;
  43.             add(local[a],);
  44.         }
  45.         for(int i=;i<len-; ++i)
  46.             printf("%d ",ans[i]);
  47.         printf("%d\n",ans[len-]);
  48.     }
  49.     return ;
  50. }

uva11525 这个题说的是给了1到K的数列 求出这个数列 的 第n 大 当然按照字典序排列,  因为 n=Si(k-i)!+Si-1(k-(i-1))!+...S0(k-k)! 经过分析我们可以得出这样的一个结论就是Si 代表的是剩下的第几大的数 然后二分去用树状数组照这个点

  1. #include <iostream>
  2. #include<cstdio>
  3. #include <string.h>
  4. using namespace std;
  5. const int maxn = ;
  6. int n,K,S[maxn],ans[maxn],C[maxn];
  7. int lowbit(int x){
  8.    return x&(-x);
  9. }
  10. void add(int x,int d){
  11.     while(x<=K){
  12.          C[x] += d; x+=lowbit(x);
  13.     }
  14. }
  15. int sum(int x){
  16.    int ans=;
  17.    while(x>){
  18.       ans+=C[x]; x-=lowbit(x);
  19.    }
  20.    return ans;
  21. }
  22. int main()
  23. {
  24.     int t;
  25.     scanf("%d",&t);
  26.     while(t--){
  27.         memset(C,,sizeof(C));
  28.         scanf("%d",&K);
  29.         for( int i=; i<K; ++i )
  30.             scanf("%d",&S[i]);
  31.         for(int i=; i<=K ; ++i)
  32.             add(i,);
  33.         for(int i=; i<K; ++i){
  34.             int L=,R=K;
  35.             while(L<R){
  36.                 int mid=L+((R-L)>>);
  37.                 int num=sum(mid);
  38.                 if(num>=(S[i]+))
  39.                     R=mid;
  40.                 else L=mid+;
  41.             }
  42.             add(L,-);
  43.             ans[i]=L;
  44.         }
  45.         for(int i=;i<K-; ++i)
  46.             printf("%d ",ans[i]);
  47.         printf("%d\n",ans[K-]);
  48.     }
  49.     return ;
  50. }

hdu4863 这题说的是给了 一个公司有 M 个任务 但是有N 台机器每台机器 只能完成一项任务,每个任务只允许一台机器完成,每个任务有一个完成时间和等级 , 每台机器有等级和所能承受的最大时间,然后我们先将按照时间排序 时间形同的任务 ,等级大的放前面,然后每次将时间大于等于当前任务的机器的等级放入树状数组中每次去修改树状数组

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <string.h>
  4. #include <algorithm>
  5. using namespace std;
  6. struct point{
  7.    int timef,rankf;
  8.    bool operator < (const point A) const{
  9.       return timef>A.timef||(timef==A.timef&&rankf>=A.rankf);
  10.    }
  11. }Task[],machine[];
  12. __int64 X[],Y[];
  13. int lowbit(int x){
  14.   return x&(-x);
  15. }
  16. void add(__int64 *C, int x, int d,int N){
  17.     while(x<=N){
  18.         C[x]+=d; x+=lowbit(x);
  19.     }
  20. }
  21. __int64 sum(__int64 *C, int x){
  22.     __int64 ans=;
  23.     while(x>){
  24.         ans+=C[x]; x-=lowbit(x);
  25.     }
  26.     return ans;
  27. }
  28. bool bit_time(int D)
  29. {
  30.    __int64 zong = sum(X,);
  31.    __int64 di=sum(X,D-);
  32.    if(zong-di<=)return false;
  33.   // add(X,D,-1,1440);
  34.    return  true;
  35. }
  36. bool bit_rank(int D)
  37. {
  38.    __int64 zong = sum(Y,);
  39.    __int64 di = sum(Y,D-);
  40.    __int64 er = zong-di;
  41.    if(er<=)return false;
  42.    int L = D , R =;
  43.    while(L<R){
  44.       int mid=(R+L)/;
  45.       __int64 W =sum(Y,mid)-di;
  46.       if(W==)L=mid+;
  47.       else R=mid;
  48.    }
  49.    add(Y,L,-,);
  50.    return true;
  51. }
  52. void solve(int N,int M)
  53. {
  54.       __int64 ans=;
  55.       int s=,num=;
  56.       for(int i=; i<N; ++i)
  57.         {
  58.              add(X,machine[i].timef,,);
  59.         }
  60.  
  61.       for(int i=; i<M; ++i){
  62.            while(s<N&&machine[s].timef>=Task[i].timef){
  63.                 add(Y,machine[s].rankf,,);
  64.                 s++;
  65.            }
  66.            if(bit_time(Task[i].timef)){
  67.               if(bit_rank(Task[i].rankf)){
  68.                     add(X,Task[i].timef,-,);
  69.                  ans+= *Task[i].timef+*(Task[i].rankf-);
  70.                  num++;
  71.               }
  72.            }
  73.       }
  74.       printf("%d %I64d\n",num,ans);
  75. }
  76. int main()
  77. {
  78.      int N,M;
  79.      while(scanf("%d%d",&N,&M)==)
  80.         {
  81.             memset(X,,sizeof(X));
  82.             memset(Y,,sizeof(Y));
  83.               for(int i = ; i<N; ++i){
  84.                 scanf("%d%d",&machine[i].timef,&machine[i].rankf);
  85.                 machine[i].rankf++;
  86.               }
  87.               for(int i=; i<M; ++i){
  88.                     scanf("%d%d",&Task[i].timef,&Task[i].rankf);
  89.                     Task[i].rankf++;
  90.               }
  91.               sort(machine,machine+N);
  92.               sort(Task,Task+M);
  93.               solve(N,M);
  94.         }
  95.     return ;
  96. }
  97. /*
  98. 3 4
  99. 100 3
  100. 101 2
  101. 99 2
  102. 99 3
  103. 100 3
  104. 100 2
  105. 99 2
  106.  
  107. */

cf459D 题说的是 计算 [1,i] 中 值等于ai 的个数 x1， 求出[j,n]中 aj的 个数 x2 其中i小于 j 然后求出，使得x1小于x2的ij的对数，首先对数组进行离散然后，从后往前每个位子都将从该位置的aj以及该位置以后aj的个数，插入树状数组中去，然后 枚举每一个i并将相应的aj个数从 树状数组中删去然后 对于每一个ai个数 在数组中找出小于该个数长度的数有多少个，每次加起来就可以了

的

Fenwick的更多相关文章

  1. POJ 3321 Apple Tree DFS序+fenwick

    题目大意:有一颗长满苹果的苹果树,有两个操作. 1.询问以一个点为根的子树中有多少个苹果. 2.看看一个点有没有苹果,假设没有苹果.那么那里就立即长出一个苹果(= =!):否则就把那个苹果摘下来. 思 ...

  2. Kattis - Fenwick Tree(树状数组区间更新单点求值）

    Fenwick Tree Input The first line of input contains two integers NN, QQ, where 1≤N≤50000001≤N≤500000 ...

  3. Binary Indexed Tree (Fenwick Tree)

    Binary Indexed Tree 主要是为了存储数组前缀或或后缀和,以便计算任意一段的和.其优势在于可以常数时间处理更新(如果不需要更新直接用一个数组存储所有前缀/后缀和即可).空间复杂度O(n ...

  4. [bzoj1012](JSOI2008)最大数maxnumber(Fenwick Tree)

    Description 现在请求你维护一个数列,要求提供以下两种操作: 1. 查询操作.语法:Q L 功能:查询当前数列中末尾L个数中的最大的数,并输出这个数的值.限制:L不超过当前数列的长度. 2. ...

  5. Fenwick Tree / Binary Indexed Tree

    Motivation: Given a 1D array of n elements. [2, 5, -1, 3, 6] range sum query: what's the sum from 2n ...

  6. 315. Count of Smaller Numbers After Self(Fenwick Tree)

    You are given an integer array nums and you have to return a new counts array. The counts array has ...

  7. LA 5902 - Movie collection 树状数组（Fenwick树）

    看题传送门 题目大意:XXX喜欢看电影,他有好多好多的影碟,每个影碟都有个独立的编号.开始是从下往上影碟的顺序是n~1,他每次拿出影碟的时候,你需要输出压在该影碟上的有几个.(拿出后其他影碟顺序不变) ...

  8. LA 4329 - Ping pong 树状数组（Fenwick树）

    先放看题传送门 哭瞎了,交上去一直 Runtime error .以为那里错了. 狂改!!!!! 然后还是一直... 继续狂改!!!!... 一直.... 最后发现数组开小了.......... 果断 ...

  9. 树状数组，Fenwick Tree

    Fenwick Tree, (also known as Binary Indexed Tree,二叉索引树), is a high-performance data structure to cal ...

随机推荐

  1. C语言位操作--奇偶校验算法

    信息是以比特流的方式传输的,类似01000001.在传输过程中,有可能会发生错误,比如,我们存储了01000001,但是取出来却是01000000,即低位由0变成了1.为了检测到这种错误,我们可以通过 ...

  2. JavaScript—当前时间

    当前时间-倒计时下载 效果: 代码: <!doctype html> <html> <head> <meta http-equiv="Content ...

  3. 【CF889E】Mod Mod Mod DP

    [CF889E]Mod Mod Mod 题意:给你一个序列$a_1,a_2...a_n$,定义$f(x,n)=x\mod a_n$,$f(x,i)=x\mod a_i+f(x \mod a_i,i+1 ...

  4. nodeJS删除文件

    var fs = require("fs"); var path = require("path"); deleteFolderRecursive = func ...

  5. tomcat+redis会话共享

    1.基础环境: jdk1. tomcat7 redis nginx 2.添加依赖的jar包到tomcat的lib目录(http://pan.baidu.com/s/1eRAwN0Q) 3.配置tomc ...

  6. Twig---和vue或angular前端框架并存

    <h1> {% verbatim %} {{message}} {% endverbatim %} </h1> 上面这种方式虽然能够解决,前台渲染的问题,但是还是会报错: 第二 ...

  7. vue--环境搭建（创建运行项目）

    如何搭建vue环境: 1.安装之前必须要安装 node.js 2.搭建Vue环境,安装vue的脚手架工具 npm install --global vue-cli / cnpm install --g ...

  8. 纯CSS绘制的三角形箭头图案【原创】

    参考:http://www.webhek.com/css-triangles/ 使用上下左右的三角形箭头标志,直接用css即可完成,直接附上代码. css: div#up { width: 0px; ...

  9. 线性DP总结（LIS,LCS,LCIS，最长子段和）

    做了一段时间的线性dp的题目是时候做一个总结 线性动态规划无非就是在一个数组上搞嘛, 首先看一个最简单的问题: 一,最长字段和 下面为状态转移方程 for(int i=2;i<=n;i++) { ...

  10. textField placeholder颜色,位置设置

    自定义textField继承自UITextField 重写 - (CGRect)placeholderRectForBounds:(CGRect)bounds _phoneTF.font = HPFo ...