Update fenwick.md

mhayter · mhayter · commit 5b814d83434e · 2025-12-06T01:38:49.000-08:00
diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md
@@ -167,34 +167,34 @@ You can create a Fenwick tree initialized with zeros, or you can convert an exis
 === "C++"
     ```{.cpp file=fenwick_sum}
         struct FenwickTree {
-        	vector<int> bit;  // binary indexed tree
-        	int n;
-
-        	FenwickTree(int n) {
-        		this->n = n;
-        		bit.assign(n, 0);
-        	}
-
-        	FenwickTree(vector<int> const &a) : FenwickTree(a.size()) {
-        		for (size_t i = 0; i < a.size(); i++)
-        			add(i, a[i]);
-        	}
-
-        	int sum(int r) {
-        		int ret = 0;
-        		for (; r >= 0; r = (r & (r + 1)) - 1)
-        			ret += bit[r];
-        		return ret;
-        	}
-
-        	int sum(int l, int r) {
-        		return sum(r) - sum(l - 1);
-        	}
-
-        	void add(int idx, int delta) {
-        		for (; idx < n; idx = idx | (idx + 1))
-        			bit[idx] += delta;
-        	}
+            vector<int> bit;  // binary indexed tree
+            int n;
+
+            FenwickTree(int n) {
+                this->n = n;
+                bit.assign(n, 0);
+            }
+
+            FenwickTree(vector<int> const &a) : FenwickTree(a.size()) {
+                for (size_t i = 0; i < a.size(); i++)
+                    add(i, a[i]);
+            }
+
+            int sum(int r) {
+                int ret = 0;
+                for (; r >= 0; r = (r & (r + 1)) - 1)
+                    ret += bit[r];
+                return ret;
+            }
+
+            int sum(int l, int r) {
+                return sum(r) - sum(l - 1);
+            }
+
+            void add(int idx, int delta) {
+                for (; idx < n; idx = idx | (idx + 1))
+                    bit[idx] += delta;
+            }
         };
     ```
 === "Python"
@@ -255,31 +255,31 @@ Both significant limitations are because the $min$ operation together with the s
 === "C++"
     ```{.cpp file=fenwick_min}
         struct FenwickTreeMin {
-        	vector<int> bit;
-        	int n;
-        	const int INF = (int)1e9;
-
-        	FenwickTreeMin(int n) {
-        		this->n = n;
-        		bit.assign(n, INF);
-        	}
-
-        	FenwickTreeMin(vector<int> a) : FenwickTreeMin(a.size()) {
-        		for (size_t i = 0; i < a.size(); i++)
-        			update(i, a[i]);
-        	}
-
-        	int getmin(int r) {
-        		int ret = INF;
-        		for (; r >= 0; r = (r & (r + 1)) - 1)
-        			ret = min(ret, bit[r]);
-        		return ret;
-        	}
-
-        	void update(int idx, int val) {
-        		for (; idx < n; idx = idx | (idx + 1))
-        			bit[idx] = min(bit[idx], val);
-        	}
+            vector<int> bit;
+            int n;
+            const int INF = (int)1e9;
+
+            FenwickTreeMin(int n) {
+                this->n = n;
+                bit.assign(n, INF);
+            }
+
+            FenwickTreeMin(vector<int> a) : FenwickTreeMin(a.size()) {
+                for (size_t i = 0; i < a.size(); i++)
+                    update(i, a[i]);
+            }
+
+            int getmin(int r) {
+                int ret = INF;
+                for (; r >= 0; r = (r & (r + 1)) - 1)
+                    ret = min(ret, bit[r]);
+                return ret;
+            }
+
+            void update(int idx, int val) {
+                for (; idx < n; idx = idx | (idx + 1))
+                    bit[idx] = min(bit[idx], val);
+            }
         };
     ```
 === "Python"
@@ -348,7 +348,7 @@ As claimed before, it is very easy to implement Fenwick Tree for multidimensiona
 === "Python"
     ```py
     class FenwickTree2D:
-	
+    
         def __init__(self, n: int, m: int) -> None:
             self.n = n
             self.m = m
@@ -438,41 +438,41 @@ The following implementation can be used like the other implementations, however
 === "C++"
     ```{.cpp file=fenwick_sum_onebased}
     struct FenwickTreeOneBasedIndexing {
-    	vector<int> bit;  // binary indexed tree
-    	int n;
-
-    	FenwickTreeOneBasedIndexing(int n) {
-    		this->n = n + 1;
-    		bit.assign(n + 1, 0);
-    	}
-
-    	FenwickTreeOneBasedIndexing(vector<int> a)
-    		: FenwickTreeOneBasedIndexing(a.size()) {
-    		for (size_t i = 0; i < a.size(); i++)
-    			add(i, a[i]);
-    	}
-
-    	int sum(int idx) {
-    		int ret = 0;
-    		for (++idx; idx > 0; idx -= idx & -idx)
-    			ret += bit[idx];
-    		return ret;
-    	}
-
-    	int sum(int l, int r) {
-    		return sum(r) - sum(l - 1);
-    	}
-
-    	void add(int idx, int delta) {
-    		for (++idx; idx < n; idx += idx & -idx)
-    			bit[idx] += delta;
-    	}
+        vector<int> bit;  // binary indexed tree
+        int n;
+
+        FenwickTreeOneBasedIndexing(int n) {
+            this->n = n + 1;
+            bit.assign(n + 1, 0);
+        }
+
+        FenwickTreeOneBasedIndexing(vector<int> a)
+            : FenwickTreeOneBasedIndexing(a.size()) {
+            for (size_t i = 0; i < a.size(); i++)
+                add(i, a[i]);
+        }
+
+        int sum(int idx) {
+            int ret = 0;
+            for (++idx; idx > 0; idx -= idx & -idx)
+                ret += bit[idx];
+            return ret;
+        }
+
+        int sum(int l, int r) {
+            return sum(r) - sum(l - 1);
+        }
+
+        void add(int idx, int delta) {
+            for (++idx; idx < n; idx += idx & -idx)
+                bit[idx] += delta;
+        }
     };
     ```
 === "Python"
     ```py
     class FenwickTreeOneBasedIndexing:
-	
+    
         def __init__(self, a: Union[int, List[int]]) -> None:
             if isinstance(a, int):
                 self.n = a + 1
