树状数组总结——详解（单点/区间查询， 单点/区间修改， 逆序对）

最新推荐文章于 2022-11-01 15:10:38 发布
最新推荐文章于 2022-11-01 15:10:38 发布
阅读量560 收藏
点赞数

http://blog.csdn.net/wzw1376124061/article/details/73188238

2017-06-13 17:24 64人阅读 评论(0) 收藏 举报

版权声明：！！！本文为博主原创文章，若转载请附博主链接，一经发现盗版将追究责任。！！！

1、概述

　　树状数组(binary indexed tree)，是一种设计新颖的数组结构，它能够高效地获取数组中连续n个数的和。概括说，树状数组通常用于解决以下问题：数组{a}中的元素可能不断地被修改，怎样才能快速地获取连续几个数的和？

2、树状数组基本操作

　　传统数组(共n个元素)的元素修改和连续元素求和的复杂度分别为O(1)和O(n)。树状数组通过将线性结构转换成伪树状结构（线性结构只能逐个扫描元素，而树状结构可以实现跳跃式扫描），使得修改和求和复杂度均为O(lgn)，大大提高了整体效率。

给定序列（数列）A，我们设一个数组C满足

C[i] = A[i–2^k+ 1] + … + A[i]

其中，k为i在二进制下末尾0的个数，i从1开始算！

则我们称C为树状数组。

下面的问题是，给定i，如何求2^k?

答案很简单：2^k=i&(i^(i-1)) ，也就是i&(-i)

下面进行解释：

以i=6为例（注意：a_x表示数字a是x进制表示形式）：

(i)_10 = (0110)_2

(i-1)_10=(0101)_2

i xor (i-1) =(0011)_2

i and (i xor (i-1))  =(0010)_2

2^k = 2

C[6] = C[6-2+1]+…+A[6]=A[5]+A[6]

　数组C的具体含义如下图所示：

　　当我们修改A[i]的值时，可以从C[i]往根节点一路上溯，调整这条路上的所有C[]即可，这个操作的复杂度在最坏情况下就是树的高度即O(logn)。另外，对于求数列的前n项和，只需找到n以前的所有最大子树，把其根节点的C加起来即可。不难发现，这些子树的数目是n在二进制时1的个数，或者说是把n展开成2的幂方和时的项数,因此，求和操作的复杂度也是O(logn)。

　　树状数组能快速求任意区间的和：A[i] + A[i+1] + … + A[j]，设sum(k) = A[1]+A[2]+…+A[k]，则A[i] + A[i+1] + … + A[j] = sum(j)-sum(i-1)。


  • 单点修改  &&  区间查询

         已知一个数列，你需要进行下面两种操作：

                   1.将某一个数加上x

                   2.求出某区间每一个数的和

[cpp] view plain copy print ?
  1. /************************************************************************* 
  2.      > Author: wzw-cnyali 
  3.      > Created Time: 2017/6/13 10:33:11 
  4.  ************************************************************************/  
  5.   
  6. #prag\  
  7. ma GCC optimize("O3")  
  8.   
  9. #include<iostream>  
  10. #include<cstdio>  
  11. #include<cstdlib>  
  12. #include<cmath>  
  13. #include<cstring>  
  14. #include<algorithm>  
  15.   
  16. using namespace std;  
  17.   
  18. typedef long long LL;  
  19.   
  20. typedef unsigned long long uLL;  
  21.   
  22. #define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)  
  23. #define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)  
  24. #define EREP(i, a) for(register int i = (be[a]); i != -1; i = nxt[i])  
  25. #define debug(...) fprintf(stderr, __VA_ARGS__)  
  26. #define mem(a, b) memset((a), b, sizeof(a))  
  27.   
  28. template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }  
  29. template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }  
  30.   
  31. char buff[1 << 25], *buf = buff;  
  32.   
  33. template <class T>  
  34. T read(T sum = 0, T fg = 0)  
  35. {  
  36.     while(*buf < '0' || *buf > '9') { fg |= *buf == '-'; buf++; }  
  37.     while(*buf >= '0' && *buf <= '9') { sum = sum * 10 + *buf - '0'; buf++; }  
  38.     return fg ? -sum : sum;  
  39. }  
  40.   
  41. const int inf = 1e9;  
  42.   
  43. const LL INF = 1e17;  
  44.   
  45. const int Size = 500010;  
  46.   
  47. const int maxn = 100000;  
  48.   
  49. const int maxm = 100000;  
  50.   
  51. int n, m;  
  52. int a[Size];  
  53.   
  54. struct index_tree  
  55. {  
  56. #define lowbit(x) ((x) & (-x))  
  57.     void add(int x, int val)  
  58.     {  
  59.         for(; x <= n; x += lowbit(x)) a[x] += val;  
  60.     }  
  61.     int query(int x)  
  62.     {  
  63.         int ans = 0;  
  64.         for(; x; x -= lowbit(x)) ans += a[x];  
  65.         return ans;  
  66.     }  
  67. }tree;  
  68.   
  69. int main()  
  70. {  
  71. #ifndef ONLINE_JUDGE  
  72.     freopen("input.in", "r", stdin);  
  73.     freopen("output.out", "w", stdout);  
  74. #endif  
  75.     fread(buff, 1, 1 << 25, stdin);  
  76.     n = read<int>(), m = read<int>();  
  77.     REP(i, 1, n) tree.add(i, read<int>());  
  78.     while(m--)  
  79.     {  
  80.         int tp = read<int>();  
  81.         if(tp == 1)  
  82.         {  
  83.             int x = read<int>(), val = read<int>();  
  84.             tree.add(x, val);  
  85.         }  
  86.         else  
  87.         {  
  88.             int x = read<int>(), y = read<int>();  
  89.             printf("%d\n", tree.query(y) - tree.query(x - 1));  
  90.         }  
  91.     }  
  92.     return 0;  
  93. }  
题目链接： https://www.luogu.org/problem/show?pid=3374


  • 区间修改  &&  单点查询

                已知一个数列，你需要进行下面两种操作：

                        1.将某区间每一个数数加上x

                        2.求出某一个数的值

               思路：

        这里要引入差分数组这种东西，我们记d[i] = a[i] - a[i-1]（a为原数组），这样我们记sigma（d[i]） = a[i] ，为什么呢，观察式子sigma(d[i]) = a[1] + a[2] - a[1] +ａ［３］．．．这样一直下去就得到了我们的原数组。
有什么用呢？如果我们往一段区间上加ｋ，在差分数组上如何体现呢？我们举个例子：
                       ａ：１,２,３,４,５
                       ｄ：１,１,１,１,１
                       ２～４加１
        如果我们盲目的在２到４上加１，就会发现会影响后面的数（因为是前缀和），所以我们在２这个位置加一，用树状数组更新，在５的位置减一用树状数组更新就ｏｋ了
                       ａ：１，３，４，５，５
                       ｄ：１，２，１，１，０

[cpp] view plain copy print ?
  1. /************************************************************************* 
  2.      > Author: wzw-cnyali 
  3.      > Created Time: 2017/6/13 11:11:16 
  4.  ************************************************************************/  
  5.   
  6. #include<iostream>  
  7. #include<cstdio>  
  8. #include<cstdlib>  
  9. #include<cmath>  
  10. #include<cstring>  
  11. #include<algorithm>  
  12.   
  13. #prag\  
  14. ma GCC optimize("O3")  
  15.   
  16. using namespace std;  
  17.   
  18. typedef long long LL;  
  19.   
  20. typedef unsigned long long uLL;  
  21.   
  22. #define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)  
  23. #define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)  
  24. #define EREP(i, a) for(register int i = (be[a]); i != -1; i = nxt[i])  
  25. #define debug(...) fprintf(stderr, __VA_ARGS__)  
  26. #define mem(a, b) memset((a), b, sizeof(a))  
  27.   
  28. template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }  
  29. template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }  
  30.   
  31. char buff[1 << 25], *buf = buff;  
  32.   
  33. template <class T>  
  34. T Fread(T sum = 0, T fg = 0)  
  35. {  
  36.     while(*buf < '0' || *buf > '9') { fg |= *buf == '-'; buf++; }  
  37.     while(*buf >= '0' && *buf <= '9') { sum = sum * 10 + *buf - '0'; buf++; }  
  38.     return fg ? -sum : sum;  
  39. }  
  40.   
  41. template <class T>  
  42. T read(T sum = 0, T fg = 0)  
  43. {  
  44.     char c = getchar();  
  45.     while(c < '0' || c > '9') { fg |= c == '-'; c = getchar(); }  
  46.     while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }  
  47.     return fg ? -sum : sum;  
  48. }  
  49.   
  50. const int inf = 1e9;  
  51.   
  52. const LL INF = 1e17;  
  53.   
  54. const int Size = 500010;  
  55.   
  56. const int maxn = 100000;  
  57.   
  58. const int maxm = 100000;  
  59.   
  60. int n, m;  
  61. int a[Size];  
  62.   
  63. struct index_tree   
  64. {  
  65. #define lowbit(x) ((x) & (-x))  
  66.     int tree[Size];  
  67.   
  68.     void add(int x, int val)  
  69.     {  
  70.         for(; x <= n; x += lowbit(x)) tree[x] += val;  
  71.     }  
  72.   
  73.     int query(int x)  
  74.     {  
  75.         int ans = 0;  
  76.         for(; x; x -= lowbit(x)) ans += tree[x];  
  77.         return ans;  
  78.     }  
  79. }tree;  
  80.   
  81. int main()  
  82. {  
  83. #ifndef ONLINE_JUDGE  
  84.     freopen("input.in", "r", stdin);  
  85.     freopen("output.out", "w", stdout);  
  86. #endif  
  87.     fread(buff, 1, 1 << 25, stdin);  
  88.     n = Fread<int>(), m = Fread<int>();  
  89.     REP(i, 1, n)  
  90.     {  
  91.         a[i] = Fread<int>();  
  92.         tree.add(i, a[i] - a[i - 1]);  
  93.     }  
  94.     while(m--)  
  95.     {  
  96.         if(Fread<int>() == 1)  
  97.         {  
  98.             int x = Fread<int>(), y = Fread<int>(), val = Fread<int>();  
  99.             tree.add(x, val);  
  100.             tree.add(y + 1, -val);  
  101.         }  
  102.         else printf("%d\n", tree.query(Fread<int>()));  
  103.     }  
  104.     return 0;  
  105. }  

题目链接：https://www.luogu.org/problem/show?pid=3368


  • 区间修改  &&  区间查询

               已知一个数列，你需要进行下面两种操作：

                        1.将某区间每一个数加上x

                        2.求出某区间每一个数的和

  首先观察式子：

a[1]+a[2]+...+a[n]

= (c[1]) + (c[1]+c[2]) + ... + (c[1]+c[2]+...+c[n]) 

= n*c[1] + (n-1)*c[2] +... +c[n]

= n * (c[1]+c[2]+...+c[n]) - (0*c[1]+1*c[2]+...+(n-1)*c[n])    (式子①)

那么我们就维护一个数组c2[n]，其中c2[i] = (i-1)*c[i]

每当修改c的时候，就同步修改一下c2，这样复杂度就不会改变

那么式子①=n*sigma(c,n) - sigma(c2,n)

于是我们做到了在O(logN)的时间内完成一次区间和查询

一件很好的事情就是树状数组的常数比其他NlogN的数据结构小得多，实际上它的计算次数比NlogN要小很多，再加上它代码短，是OI中的利器

[cpp] view plain copy print ?
  1. /************************************************************************* 
  2.      > Author: wzw-cnyali 
  3.      > Created Time: 2017/6/13 15:18:18 
  4.  ************************************************************************/  
  5.   
  6. #include<iostream>  
  7. #include<cstdio>  
  8. #include<cstdlib>  
  9. #include<cmath>  
  10. #include<cstring>  
  11. #include<algorithm>  
  12.   
  13. #prag\  
  14. ma GCC optimize("O3")  
  15.   
  16. using namespace std;  
  17.   
  18. typedef long long LL;  
  19.   
  20. typedef unsigned long long uLL;  
  21.   
  22. #define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)  
  23. #define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)  
  24. #define EREP(i, a) for(register int i = (be[a]); i != -1; i = nxt[i])  
  25. #define debug(...) fprintf(stderr, __VA_ARGS__)  
  26. #define mem(a, b) memset((a), b, sizeof(a))  
  27.   
  28. template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }  
  29. template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }  
  30.   
  31. char buff[1 << 21], *buf = buff;  
  32.   
  33. template <class T>  
  34. T Fread(T sum = 0, T fg = 0)  
  35. {  
  36.     while(*buf < '0' || *buf > '9') { fg |= *buf == '-'; buf++; }  
  37.     while(*buf >= '0' && *buf <= '9') { sum = sum * 10 + *buf - '0'; buf++; }  
  38.     return fg ? -sum : sum;  
  39. }  
  40.   
  41. template <class T>  
  42. T read(T sum = 0, T fg = 0)  
  43. {  
  44.     char c = getchar();  
  45.     while(c < '0' || c > '9') { fg |= c == '-'; c = getchar(); }  
  46.     while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }  
  47.     return fg ? -sum : sum;  
  48. }  
  49.   
  50. const int inf = 1e9;  
  51.   
  52. const LL INF = 1e17;  
  53.   
  54. const int Size = 100010;  
  55.   
  56. const int maxn = 100000;  
  57.   
  58. const int maxm = 100000;  
  59.   
  60. int n, m;  
  61.   
  62. struct index_tree   
  63. {  
  64. #define lowbit(x) ((x) & (-x))  
  65.   
  66.     void add(LL *array, int x, LL val)  
  67.     {  
  68.         for(; x <= n; x += lowbit(x)) array[x] += val;  
  69.     }  
  70.   
  71.     LL query(LL *array, int x)  
  72.     {  
  73.         LL ans = 0;  
  74.         for(; x; x -= lowbit(x)) ans += array[x];  
  75.         return ans;  
  76.     }  
  77. }tree;  
  78.   
  79. LL c1[Size], c2[Size];  
  80.   
  81. int main()  
  82. {  
  83. #ifndef ONLINE_JUDGE  
  84.     freopen("input.in", "r", stdin);  
  85.     freopen("output.out", "w", stdout);  
  86. #endif  
  87.     fread(buff, 1, 1 << 21, stdin);  
  88.     n = Fread<int>(), m = Fread<int>();  
  89.     LL last_x = 0;  
  90.     REP(i, 1, n)  
  91.     {  
  92.         LL x = Fread<LL>();  
  93.         tree.add(c1, i, x - last_x);  
  94.         tree.add(c2, i, (x - last_x) * (i - 1));  
  95.         last_x = x;  
  96.     }  
  97.     while(m--)  
  98.     {  
  99.         if(Fread<int>() == 1)  
  100.         {  
  101.             int x = Fread<int>(), y = Fread<int>();  
  102.             LL val = Fread<LL>();  
  103.             tree.add(c1, x, val); tree.add(c1, y + 1, -val);  
  104.             tree.add(c2, x, val * (x - 1)); tree.add(c2, y + 1, -val * y);  
  105.         }  
  106.         else  
  107.         {  
  108.             int x = Fread<int>(), y = Fread<int>();  
  109.             LL sum1 = (x - 1) * tree.query(c1, x - 1) - tree.query(c2, x - 1);  
  110.             LL sum2 = y * tree.query(c1, y) - tree.query(c2, y);  
  111.             printf("%lld\n", sum2 - sum1);  
  112.         }  
  113.     }  
  114.     return 0;  
  115. }  

题目链接：https://www.luogu.org/problem/show?pid=3372


  • 逆序对

             对于一个包含n个非负整数的数组a，如果有i<j，且a[i]>a[j]，则称（a[i]，A[j]）为数组a中的一个逆序对。

           即逆序数就是前面比后面大的一对数。

[cpp] view plain copy print ?
  1. /************************************************************************* 
  2.      > Author: wzw-cnyali 
  3.      > Created Time: 2017/6/13 16:59:03 
  4.  ************************************************************************/  
  5.   
  6. #include<iostream>  
  7. #include<cstdio>  
  8. #include<cstdlib>  
  9. #include<cmath>  
  10. #include<cstring>  
  11. #include<algorithm>  
  12.   
  13. #prag\  
  14. ma GCC optimize("O3")  
  15.   
  16. using namespace std;  
  17.   
  18. typedef long long LL;  
  19.   
  20. typedef unsigned long long uLL;  
  21.   
  22. #define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)  
  23. #define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)  
  24. #define EREP(i, a) for(register int i = (be[a]); i != -1; i = nxt[i])  
  25. #define debug(...) fprintf(stderr, __VA_ARGS__)  
  26. #define mem(a, b) memset((a), b, sizeof(a))  
  27.   
  28. template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }  
  29. template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }  
  30.   
  31. char buff[1 << 25], *buf = buff;  
  32.   
  33. template <class T>  
  34. T Fread(T sum = 0, T fg = 0)  
  35. {  
  36.     while(*buf < '0' || *buf > '9') { fg |= *buf == '-'; buf++; }  
  37.     while(*buf >= '0' && *buf <= '9') { sum = sum * 10 + *buf - '0'; buf++; }  
  38.     return fg ? -sum : sum;  
  39. }  
  40.   
  41. template <class T>  
  42. T read(T sum = 0, T fg = 0)  
  43. {  
  44.     char c = getchar();  
  45.     while(c < '0' || c > '9') { fg |= c == '-'; c = getchar(); }  
  46.     while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }  
  47.     return fg ? -sum : sum;  
  48. }  
  49.   
  50. const int inf = 1e9;  
  51.   
  52. const LL INF = 1e17;  
  53.   
  54. const int Size = 100000;  
  55.   
  56. const int maxn = 100000;  
  57.   
  58. const int maxm = 100000;  
  59.   
  60. int n;  
  61.   
  62. struct node  
  63. {  
  64.     int val, id;  
  65. }a[Size];  
  66.   
  67. bool cmp(node a, node b)  
  68. {  
  69.     return a.val < b.val;  
  70. }  
  71.   
  72. struct index_tree  
  73. {  
  74. #define lowbit(x) ((x) & (-x))  
  75.     int tree[Size];  
  76.     void add(int x)  
  77.     {  
  78.         for(; x <= n; x += lowbit(x)) tree[x]++;  
  79.     }  
  80.   
  81.     int query(int x)  
  82.     {  
  83.         int ans = 0;  
  84.         for(; x; x -= lowbit(x)) ans += tree[x];  
  85.         return ans;  
  86.     }  
  87. }tree;  
  88.   
  89. int c[Size];  
  90.   
  91. int main()  
  92. {  
  93. #ifndef ONLINE_JUDGE  
  94.     freopen("input.in", "r", stdin);  
  95.     freopen("output.out", "w", stdout);  
  96. #endif  
  97.     fread(buff, 1, 1 << 25, stdin);  
  98.     n = Fread<int>();  
  99.     REP(i, 1, n) a[i] = (node){Fread<int>(), i};  
  100.     sort(a + 1, a + n + 1, cmp);  
  101.   
  102.     REP(i, 1, n) c[a[i].id] = i;  
  103.   
  104.     int ans = 0;  
  105.     DREP(i, n, 1)  
  106.     {  
  107.         ans += tree.query(c[i]);  
  108.         tree.add(c[i]);  
  109.     }  
  110.     printf("%d\n", ans);  
  111.     return 0;  
  112. } 
罗旅洲
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++树状数组入门模板和简单应用+二分求逆序对
01-03
> #include using namespace std; const int MAX=50005; int a[MAX],tree[MAX],n; int lowbit(int x) //找最低位的1 { return x&-x; } void add(int i,int x)//修改数据在i加x { while(i0) { s+=tree[i]; i-=lowbit(i); } return s; } int main() { ios::sync_with_stdio(0);cin.tie(0); } 例题 树
【博客327】求逆序对的数量
qq_43684922的博客
07-04 529
内容： 记录求一组数中逆序对的数量 思路： 1、采用分治的思路 2、每次对区间分为前一半和后一半来求解 3、每次子区间求解完后都是有序的 4、由于每次对子区间求解完后是有序的，那么大区间求解的时候只需要采用一种比较方法： 从后往前，因为子区间是有序的，所以当前子区间的遍历的那个数若比另一个子区间的最后一个数大， 那么肯定就比前面所有的都大，因为子区间是有序的，此时逆序对的数量增加的值就是与你比较的子 区间的数字前面的元素个数。如果当前子区间的遍历的那个数若比另一个子区间的最后一个数小
LeetCode：327. 区间和的个数 逆序对 / multiset / 二分查找+二分插入
AKGWSB 's blog
03-25 442
给定一个整数数组 nums，返回区间和在 [lower, upper] 之间的个数，包含 lower 和 upper。 区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。 说明: 最直观的算法复杂度是 O(n2) ，请在此基础上优化你的算法。 示例: 输入: nums = [-2,5,-1], lower = -2, upper = 2...
树状数组(单点更新、区间查询/区间更新、单点查询)（update和getSum函数）————附完整代码以及示例和示例代码
韩江雪de 小屋
02-25 890
文章目录1 lowbit计算2 树状数组2.1 问题描述2.2 思想2.3 实现2.3.1设计函数getSum(x)2.3.1.1 思路2.3.1.2 实现代码2.3.2 设计函数update(x)2.3.2.1 思路2.3.2.2 实现代码2.4 应用2.4.1 问题描述（统计序列中在元素x左边比小的元素个数）2.4.2 实现代码2.4.3 扩展一——离散化（统计序列中在元素x左边比x大（右边比...
树状数组（1.单点修改，区间查询 2.区间修改，单点查询）
weixin_53024141的博客
09-03 1864
一种较高级的数据结构——树状数组，综合降低了数组中修改和查询操作的复杂度，相比于线段树，代码实现更为简短且易理解。
树状数组（单点修改+单点查询+区间修改+区间查询）
水，全都是水
09-28 1490
树状数组（单点修改+单点查询+区间修改+区间查询）
高级数据结构：树状数组（区间修改、逆序对问题）
yuhaomogui的博客
09-25 1074
我们经常会遇到求一段区间的连续和问题，直接暴力求解（从左端点一直累加到右端点）时间复杂度为o(n)，貌似也不低...但是对于有m次询问的题，时间复杂度为O(mn)就显得有点捉襟见肘了，此时一个好的想法就是使用前缀和数组。所谓前缀和数组，顾名思义就是维护段序列的前缀和的数组，其实现也相当简单：定义前缀和数组sum[N]，全部初始化为0，输入第i个数据x时，只要将sum[i]=sum[i-1]+x，就能递推得到整个前缀和数组，但要注意i要从1开始。得到了前缀和数组，我们再来看求一段区间的连续和问题，如果左端点.
树状数组 --区间查询+区间修改
mlm5678的博客
01-30 362
树状数组 --区间查询+区间修改 树状数组的作用：频繁对于单点和区间修改和查询操作，时间复杂度都是log(n). 1. 追溯其父节点或下辖第一个没有关系的点： (所有操作都是围绕这个) int lowbit (int x) { return x&(-x); }                    2. 修改元素的值//让A[X]增加d void add(int k,int num)
逆序对（树状数组） C语言
01-03
广工《算法和高级数据结构教程》 逆序对（树状数组） c语言实现
算法设计之分治思想（求数组的逆序对）
01-21
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。 示例 1: 输入: [7,5,6,4] 输出: 5 限制： 0 <= 数组长度 <= 50000 首先最...
剑指offer -数组中的逆序对 – python
12-22
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P00000007 思路 根据题目描述可知，...
树状数组（单点更新，区间查询；区间更新，单点查询；二维数组的树状数组实现）
qq_51825761的博客
11-01 96
将x转换为二进制，则lowbit(x)就是右边第一个'1'号位表示的位权。将x转换为二进制，则lowbit(x)就是右边第一个'1'号位表示的位权。将x转换为二进制，则lowbit(x)就是右边第一个'1'号位表示的位权。返回二维矩阵a[1][1]到a[i][j](一个子矩阵)的和。///c[x]存储a[x](含x号位)前Lowbit(x)个数。lowbit 可以理解为能整除x的最大的2的幂次。lowbit 可以理解为能整除x的最大的2的幂次。lowbit 可以理解为能整除x的最大的2的幂次。
【51nod 1215】数组的宽度
weixin_43438700的博客
10-24 284
N个整数组成的数组，定义子数组a[i]…a[j]的宽度为：max(a[i]…a[j]) - min(a[i]…a[j])，求所有子数组的宽度和。 思路： 维护两个单调栈，累加最大值*最大值覆盖的区间长度maxsum 和 最小值与最小值福海区间长度minsum maxsum-minsum就是答案 代码： #include<iostream> #include<cstdio> ...
SP1043 GSS1 - Can you answer these queries I 线段树 求最大子段和板子
Up Panda
10-28 127
LINK 题目描述 给出了序列 A[1],A[2],…,A[N]A[1],A[2],…,A[N]A[1],A[2],…,A[N] 。 (a[i]≤15007,1≤N≤50000 a[i]≤15007,1≤N≤50000a[i]≤15007,1≤N≤50000 )。查询定义如下： 查询 (x,y)=max⁡{a[i]+a[i+1]+…+a[j];x≤i≤j≤y}(x,y)=\max{a[i]+a[i...
【原创】树状数组 单点修改区间修改单点查询区间查询 逆序对 二维偏序 （未完成）
致上
11-17 190
BIT
树状数组详解（区间修改和单点查询）
Wu_while的博客
08-07 1203
前置芝士 单点修改和区间查询 引入 先看例题：（洛谷 P3368 【模板】树状数组 2） 已知一个数列，你需要进行下面两种操作： 1.将某区间每一个数数加上 xxx； 2.求出某一个数的值。 这题和 树状数组1 有什么区别？ 没错，正如题目所说，这题是区间修改和单点查询！ 区间修改和单点查询 区间修改和单点查询要怎么实现呢？这需要用到一个东西：差分。 差分是什么呢？（知道的大佬可以跳过） 对于一个数组a[]a[]a[]，我们设它的差分数组为b[]b[]b[]，则满足： b[1]=a[1]b[1]=a[1
求逆序对个数的三种方法(归并排序，树状数组，权值线段树)
Galaxy_yr的博客
11-02 4647
求逆序对个数的三种方法 逆序对: 对于一个序列 a1a_1a1​,a2a_2a2​,a3a_3a3​…ana_nan​,如果存在aia_iai​&amp;gt;aja_jaj​且i&amp;lt;j,则aia_iai​和aja_jaj​为一个逆序对。 这里将介绍3种求逆序对对数的方法。 在此之前，默认为你已经会了归并排序，树状数组和线段树。（不会的可以百度学习一下） 1.归并排序求逆序对 这应该是几乎人人都会的方...
jedis示例代码压缩包
最新发布
04-23
jedis示例代码
树状数组求逆序对 时间复杂度
09-11
树状数组求逆序对的时间复杂度为O(nlogn)，其中n为数组的大小。 树状数组（也称为BIT，Binary Indexed Tree）是一种高效的数据结构，可以用来求解一些区间操作的问题。对于求逆序对的问题，我们可以利用树状数组来统计每个元素之前的比它大的元素个数。 具体实现过程如下： 1. 首先，将原始数组按照从大到小的顺序排序，并用排名表示每个元素的位置。 2. 创建一个初始值为0的树状数组，并将排名依次插入树状数组中。 3. 从右往左遍历原始数组，对于每个元素，查询树状数组中排名小于它的元素个数，并将该元素的排名插入树状数组中。 4. 统计所有查询的结果之和即为逆序对的个数。 在以上过程中，查询和插入操作都可以在O(logn)的时间复杂度内完成，因此总的时间复杂度为O(nlogn)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值