feat: add solutions to lc problem: No.0307 (#1959)

No.0307.Range Sum Query - Mutable

Author: yanglbme

solution/0300-0399/0307.Range Sum Query - Mutable/README.md

@@ -1,56 +1,52 @@
-class BinaryIndexedTree {
-public:
-    int n;
-    vector<int> c;
-
-    BinaryIndexedTree(int _n)
-        : n(_n)
-        , c(_n + 1) {}
-
-    void update(int x, int delta) {
-        while (x <= n) {
-            c[x] += delta;
-            x += lowbit(x);
-        }
-    }
-
-    int query(int x) {
-        int s = 0;
-        while (x > 0) {
-            s += c[x];
-            x -= lowbit(x);
-        }
-        return s;
-    }
-
-    int lowbit(int x) {
-        return x & -x;
-    }
-};
-
-class NumArray {
-public:
-    BinaryIndexedTree* tree;
-
-    NumArray(vector<int>& nums) {
-        int n = nums.size();
-        tree = new BinaryIndexedTree(n);
-        for (int i = 0; i < n; ++i) tree->update(i + 1, nums[i]);
-    }
-
-    void update(int index, int val) {
-        int prev = sumRange(index, index);
-        tree->update(index + 1, val - prev);
-    }
-
-    int sumRange(int left, int right) {
-        return tree->query(right + 1) - tree->query(left);
-    }
-};
-
-/**
- * Your NumArray object will be instantiated and called as such:
- * NumArray* obj = new NumArray(nums);
- * obj->update(index,val);
- * int param_2 = obj->sumRange(left,right);
+class BinaryIndexedTree {
+public:
+    int n;
+    vector<int> c;
+
+    BinaryIndexedTree(int _n)
+        : n(_n)
+        , c(_n + 1) {}
+
+    void update(int x, int delta) {
+        while (x <= n) {
+            c[x] += delta;
+            x += x & -x;
+        }
+    }
+
+    int query(int x) {
+        int s = 0;
+        while (x > 0) {
+            s += c[x];
+            x -= x & -x;
+        }
+        return s;
+    }
+};
+
+class NumArray {
+public:
+    BinaryIndexedTree* tree;
+
+    NumArray(vector<int>& nums) {
+        int n = nums.size();
+        tree = new BinaryIndexedTree(n);
+        for (int i = 0; i < n; ++i) tree->update(i + 1, nums[i]);
+    }
+
+    void update(int index, int val) {
+        int prev = sumRange(index, index);
+        tree->update(index + 1, val - prev);
+    }
+
+    int sumRange(int left, int right) {
+        return tree->query(right + 1) - tree->query(left);
+    }
+};
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray* obj = new NumArray(nums);
+ * obj->update(index,val);
+ * int param_2 = obj->sumRange(left,right);
  */

solution/0300-0399/0307.Range Sum Query - Mutable/README_EN.md

@@ -1,75 +1,53 @@
-public class NumArray {
-    private int[] sums;
-    private int numsCount;
-    private int sumsCount;
+class BinaryIndexedTree {
+    private int n;
+    private int[] c;
 
-    public NumArray(int[] nums) {
-        numsCount = nums.Length;
-        sumsCount = 1;
-        var x = numsCount;
-        while (x > 1)
-        {
-            x /= 2;
-            sumsCount *= 2;
+    public BinaryIndexedTree(int n) {
+        this.n = n;
+        c = new int[n + 1];
+    }
+
+    public void Update(int x, int delta) {
+        while (x <= n) {
+            c[x] += delta;
+            x += x & -x;
         }
-        sumsCount = sumsCount * 2 - 1 + numsCount;
-        sums = new int[sumsCount + 1];
+    }
 
-        for (var i = sumsCount; i > 0; --i)
-        {
-            if (i - sumsCount + numsCount - 1 >= 0)
-            {
-                sums[i] = nums[i - sumsCount + numsCount - 1];
-            }
-            else
-            {
-                var l = i * 2;
-                var r = l + 1;
-                if (l <= sumsCount)
-                {
-                    sums[i] += sums[l];
-                    if (r <= sumsCount)
-                    {
-                        sums[i] += sums[r];
-                    }
-                }
-            }
+    public int Query(int x) {
+        int s = 0;
+        while (x > 0) {
+            s += c[x];
+            x -= x & -x;
         }
-        //System.Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(sums));
+        return s;
     }
+}
 
-    public void Update(int i, int val) {
-        var j = sumsCount - numsCount + i + 1;
-        sums[j] = val;
-        for (j /= 2; j > 0; j /= 2)
-        {
-            var l = j * 2;
-            var r = l + 1;
-            sums[j] = sums[l];
-            if (r <= sumsCount)
-            {
-                sums[j] += sums[r];
-            }
+public class NumArray {
+    private BinaryIndexedTree tree;
+
+    public NumArray(int[] nums) {
+        int n = nums.Length;
+        tree = new BinaryIndexedTree(n);
+        for (int i = 0; i < n; ++i) {
+            tree.Update(i + 1, nums[i]);
         }
-        //System.Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(sums));
     }
 
-    public int SumRange(int i, int j) {
-        return SumFromStart(j) - SumFromStart(i - 1);
+    public void Update(int index, int val) {
+        int prev = SumRange(index, index);
+        tree.Update(index + 1, val - prev);
     }
 
-    private int SumFromStart(int i)
-    {
-        if (i < 0) return 0;
-        var j = sumsCount - numsCount + i + 1;
-        var sum = sums[j];
-        for (; j / 2 > 0; j /= 2)
-        {
-            if (j % 2 != 0)
-            {
-                sum += sums[j - 1];
-            }
-        }
-        return sum;
+    public int SumRange(int left, int right) {
+        return tree.Query(right + 1) - tree.Query(left);
     }
-}
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.Update(index,val);
+ * int param_2 = obj.SumRange(left,right);
+ */

solution/0300-0399/0307.Range Sum Query - Mutable/Solution.cpp

@@ -8,22 +8,15 @@ func newBinaryIndexedTree(n int) *BinaryIndexedTree {
 	return &BinaryIndexedTree{n, c}
 }
 
-func (this *BinaryIndexedTree) lowbit(x int) int {
-	return x & -x
-}
-
-func (this *BinaryIndexedTree) update(x, delta int) {
-	for x <= this.n {
-		this.c[x] += delta
-		x += this.lowbit(x)
+func (t *BinaryIndexedTree) update(x, delta int) {
+	for ; x <= t.n; x += x & -x {
+		t.c[x] += delta
 	}
 }
 
-func (this *BinaryIndexedTree) query(x int) int {
-	s := 0
-	for x > 0 {
-		s += this.c[x]
-		x -= this.lowbit(x)
+func (t *BinaryIndexedTree) query(x int) (s int) {
+	for ; x > 0; x -= x & -x {
+		s += t.c[x]
 	}
 	return s
 }
@@ -40,13 +33,13 @@ func Constructor(nums []int) NumArray {
 	return NumArray{tree}
 }
 
-func (this *NumArray) Update(index int, val int) {
-	prev := this.SumRange(index, index)
-	this.tree.update(index+1, val-prev)
+func (t *NumArray) Update(index int, val int) {
+	prev := t.SumRange(index, index)
+	t.tree.update(index+1, val-prev)
 }
 
-func (this *NumArray) SumRange(left int, right int) int {
-	return this.tree.query(right+1) - this.tree.query(left)
+func (t *NumArray) SumRange(left int, right int) int {
+	return t.tree.query(right+1) - t.tree.query(left)
 }
 
 /**

solution/0300-0399/0307.Range Sum Query - Mutable/Solution.cs

@@ -1,57 +1,53 @@
-class BinaryIndexedTree {
-    private int n;
-    private int[] c;
-
-    public BinaryIndexedTree(int n) {
-        this.n = n;
-        c = new int[n + 1];
-    }
-
-    public void update(int x, int delta) {
-        while (x <= n) {
-            c[x] += delta;
-            x += lowbit(x);
-        }
-    }
-
-    public int query(int x) {
-        int s = 0;
-        while (x > 0) {
-            s += c[x];
-            x -= lowbit(x);
-        }
-        return s;
-    }
-
-    public static int lowbit(int x) {
-        return x & -x;
-    }
-}
-
-class NumArray {
-    private BinaryIndexedTree tree;
-
-    public NumArray(int[] nums) {
-        int n = nums.length;
-        tree = new BinaryIndexedTree(n);
-        for (int i = 0; i < n; ++i) {
-            tree.update(i + 1, nums[i]);
-        }
-    }
-
-    public void update(int index, int val) {
-        int prev = sumRange(index, index);
-        tree.update(index + 1, val - prev);
-    }
-
-    public int sumRange(int left, int right) {
-        return tree.query(right + 1) - tree.query(left);
-    }
-}
-
-/**
- * Your NumArray object will be instantiated and called as such:
- * NumArray obj = new NumArray(nums);
- * obj.update(index,val);
- * int param_2 = obj.sumRange(left,right);
+class BinaryIndexedTree {
+    private int n;
+    private int[] c;
+
+    public BinaryIndexedTree(int n) {
+        this.n = n;
+        c = new int[n + 1];
+    }
+
+    public void update(int x, int delta) {
+        while (x <= n) {
+            c[x] += delta;
+            x += x & -x;
+        }
+    }
+
+    public int query(int x) {
+        int s = 0;
+        while (x > 0) {
+            s += c[x];
+            x -= x & -x;
+        }
+        return s;
+    }
+}
+
+class NumArray {
+    private BinaryIndexedTree tree;
+
+    public NumArray(int[] nums) {
+        int n = nums.length;
+        tree = new BinaryIndexedTree(n);
+        for (int i = 0; i < n; ++i) {
+            tree.update(i + 1, nums[i]);
+        }
+    }
+
+    public void update(int index, int val) {
+        int prev = sumRange(index, index);
+        tree.update(index + 1, val - prev);
+    }
+
+    public int sumRange(int left, int right) {
+        return tree.query(right + 1) - tree.query(left);
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.update(index,val);
+ * int param_2 = obj.sumRange(left,right);
  */