数组求和（可变）Range Sum Query - Mutable

最新推荐文章于 2024-07-28 15:46:11 发布

weixin_34417635

最新推荐文章于 2024-07-28 15:46:11 发布

阅读量175

点赞数

文章标签： python 数据结构与算法

原文链接：https://my.oschina.net/liyurong/blog/1593122

版权

2019独角兽企业重金招聘Python工程师标准>>>

问题：

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

The update(i, val) function modifies nums by updating the element at index i to val.

Example:

Given nums = [1, 3, 5]

sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8

Note:

The array is only modifiable by the update function.
You may assume the number of calls to update and sumRange function is distributed evenly.

解决：

① 动态规划。因为更新和求和操作会被频繁调用，数组中的值被频繁更新，超时。

class NumArray { //超时
int[] dp;
int[] nums;
public NumArray(int[] nums) {
this.nums = nums;
dp = new int[nums.length];
if(nums.length > 0) dp[0] = nums[0];
for(int i = 1;i < nums.length;i ++){
dp[i] = dp[i - 1] + nums[i];
}
}
public void update(int i, int val) {
if(dp.length <= i) return;
if(i == 0){
nums[i] = val;
dp[0] = nums[0];
for(int j = 1;j < nums.length;j ++){
dp[j] = dp[j - 1] + nums[j];
}
}else{
nums[i] = val;
for (int j = i;j < dp.length;j ++){
dp[j] = dp[j - 1] + nums[j];
}
}
}
public int sumRange(int i, int j) {
if (i == 0){
return dp[j];
}else{
return dp[j] - dp[i - 1];
}
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* obj.update(i,val);
* int param_2 = obj.sumRange(i,j);
*/

在网上搜了一下，有Segement Tree(线段树)，Binary Indexed Tree(二叉索引树) ，和平方根分解三种办法。

②

Segment Tree：线段树，又名区间树，是一种二叉搜索树。

对于每一棵线段树上的节点，都有三个值：左区间、右区间以及权值。（当然，在某些情况下它只有左右区间，这个时候线段树只是作为维护某个值而使用的数据结构，如扫描线）。

线段树有一个非常重要的性质，就是当父亲节点的区间为[x,y]时，左孩子的区间就必定为[x,(x+y)/2],右孩子的区间必定为[(x+y)/2+1,y]。

range-sum-query-mutable

class SegmentTreeNode{//定义线段树，129ms
//线段树上的值
int start;
int end;
int sum;
SegmentTreeNode left;
SegmentTreeNode right;
public SegmentTreeNode(int start,int end,int sum){
this.start = start;
this.end = end;
this.sum = sum;
}
public SegmentTreeNode(int start,int end){
this.start = start;
this.end = end;
this.sum = 0;
}
}
public class NumArray {
SegmentTreeNode root = null;
public NumArray(int[] nums) {
if (nums == null || nums.length == 0){
return;
}
this.root = buildTree(nums,0,nums.length - 1);//构造线段树
}
public SegmentTreeNode buildTree(int[] nums,int start,int end){//构造线段树
if (nums == null || nums.length == 0 || start > end){
return null;
}
if (start == end){
return new SegmentTreeNode(start,end,nums[start]);
}
SegmentTreeNode cur = new SegmentTreeNode(start,end);
int mid = (end - start) / 2 + start;
cur.left = buildTree(nums,start,mid);
cur.right = buildTree(nums,mid + 1,end);
cur.sum = cur.left.sum + cur.right.sum;
return cur;
}
public void update(int i, int val) {
update(root,i,val);
}
public void update(SegmentTreeNode root,int i,int val){//重载方法，更新线段树
if (root == null) return;
int mid = root.start + (root.end - root.start) / 2;
if (i <= mid){//区间在左子树上
update(root.left,i,val);
}else{
update(root.right,i,val);
}
if (root.start == root.end && root.start == i){
root.sum = val;
return;
}
root.sum = root.left.sum + root.right.sum;
}
public int sumRange(int i, int j) {
return sumRange(root,i,j);
}
public int sumRange(SegmentTreeNode root,int i,int j){//重载方法求i~j的和
if (root == null || j < root.start || i > root.end || i > j){
return 0;
}
if (i == root.start && j == root.end){
return root.sum;
}
int mid = (root.end - root.start) / 2 + root.start;
int res = sumRange(root.left,i,Math.min(mid,j)) +sumRange(root.right,Math.max(mid + 1,i),j);
return res;
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* obj.update(i,val);
* int param_2 = obj.sumRange(i,j);
*/

③ 二叉树索引树（BIT）/ Fenwick树

以下面的数组为例：

1）创建：

根据前缀（将最右侧的1变为0），判断节点的层次（父节点），根节点的值为0：

对于节点1：1 --> 0 --> 父节点为0
对于节点2：10 --> 00 --> 父节点为0
对于节点3：11 --> 10 --> 父节点为2

……

对于节点11：1011 --> 1010 --> 父节点为10

得到如下图所示的二叉树：

我们知道，任意一个数都可以表示为2^x之和。因此，我们根据下列式子填充该二叉树：

对于节点1：1 = 2^0 --> 从节点0开始，向后走2^0个元素，节点1的值为nums[0] = 3;

对于节点2：2 = 2^1 --> 从节点0开始，向后走2^0个元素，节点2的值为nums[0] + nums[1] = 5;

对于节点3：3 = 2^1 + 2^0 --> 从节点2^1开始，向后走2^0个元素，节点3的值为nums[2] = -1;

对于节点4：4 = 2^2 --> 从节点0开始，向后走2^2个元素，节点4的值为nums[0] + nums[1] + nums[2] + nums[3] = 10;

对于节点5：5 = 2^2 + 2^0 --> 从节点2^2开始，向后走2^0个元素，节点5的值为nums[4] = 5;

对于节点6：6 = 2^2 + 2^1 --> 从节点2^2开始，向后走2^1个元素，节点6的值为nums[4] + nums[5] = 9;

对于节点7：7 = 2^2 + 2^1 + 2^0 --> 从节点2^2 + 2^1开始，向后走2^0个元素，节点7的值为nums[6] = -3;

……

对于节点10：10 = 2^3 + 2^1，由节点2^3开始，向后走2^1个元素，节点10的值为nums[8] + nums[9] = 9;

对于节点11：11 = 2^3 + 2^1 + 2^0，由节点2^3 + 2^1开始，向后走2^0个元素，节点11的值为nums[10] = 3;

得到如下图所示的二叉索引树：

2）求和：

sumRange（1，6）：从节点6开始，加上其父节点的值，直到根节点为止：9+10 = 19；

3）获取父节点，有三个步骤：

<1>获取该节点的二进制补码

<2>将该节点与<1>中的值进行 & 操作

<3>该节点的值 - <2>中的值

如，获取节点7的根节点：

<1> 7 = 111，二进制补码为：001

<2> 111 & 001 = 001

<3> 111 - 001 = 110 = 6

4）获取遍历过程中下一个节点的步骤：

<1>获取该节点的二进制补码

<2>将该节点与<1>中的值进行 & 操作

<3>该节点的值 + <2>中的值

如获取节点4的下一个节点：

<1> 4 = 0000000100，二进制补码为：1111111101

<2> 0000000100 & 1111111101 = 0000000100

<3> 0000000100 + 0000000100 = 0000001000 = 8

【注意】由于遍历过程中节点8 的下一个节点计算为16，超过该层的最大数2^3=8，结束循环。从下一层的第一个节点3开始继续循环。知道每层都结束完成。就可以得到完整的二叉索引树。

class NumArray { //133ms
int[] bitTree;//用于存储二叉索引树
int[] nums;
public NumArray(int[] nums) {
this.nums = nums;
bitTree = new int[nums.length + 1];
for (int i = 0;i < nums.length;i ++){
updateTree(i + 1,nums[i]);//初始化索引树
}
}
public void updateTree(int i,int val){//i表示索引，val表示值
for (int j = i;j < bitTree.length;j = j + (j & -j)){
bitTree[j] += val;
}
}
public void update(int i, int val) {
updateTree(i + 1,val - nums[i]);
nums[i] = val;
}
public int sumRange(int i, int j) {
return sumRange(j + 1) - sumRange(i);
}
public int sumRange(int i){
int sum = 0;
for (int j = i;j >= 1;j = (j - (j & (-j)))){
sum += bitTree[j];
}
return sum;
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* obj.update(i,val);
* int param_2 = obj.sumRange(i,j);
*/