Fix seg trees and dsu

Signed-off-by: Bruno Freitas Tissei <bft15@inf.ufpr.br>

algorithms/structure/disjoint_set.cpp

@@ -8,17 +8,16 @@
 
 struct DisjointSet {
   int N;
-  vector<int> h, par, size;
+  vector<int> rank, par;
 
   Disjoint(int N) :
-    N(N), h(N), par(N), size(N)
+    N(N), rank(N), par(N)
   {}
 
   /// Initializes element x.
   void make_set(int x) {
     par[x] = x;
-    h[x] = 0;
-    size[x] = 1;
+    rank[x] = 0;
   }
 
   /// Returns set index from element x.
@@ -33,16 +32,13 @@ struct DisjointSet {
     x = find_set(x);
     y = find_set(y);
 
-    if (x == y)
-      return;
+    if (x != y) {
+      if (rank[x] > rank[y]) 
+        swap(x, y);
 
-    if (h[x] > h[y])
-      swap(x, y);
-
-    par[x] = y;
-    size[y] += size[x];
-
-    if (h[x] == h[y])
-      h[x]++;
+      par[x] = y;
+      if (rank[x] == rank[y]) 
+        rank[x]++;
+    }
   }
 };

algorithms/structure/lazy_segment_tree.cpp

@@ -6,11 +6,11 @@
 ///   query_tree  -> O(log n)
 /// Complexity (Space): O(n)
 
+int N;
 struct LazySegmentTree {
-  int N;
   vector<int> tree, lazy;
 
-  LazySegmentTree(int N, const vector<int> &v) : N(N), tree(N*4), lazy(N*4) {
+  LazySegmentTree(const vector<int> &v) : tree(MAX*4), lazy(MAX*4) {
     init();
     build(v);
   }
@@ -34,9 +34,10 @@ struct LazySegmentTree {
       return;
     }
 
-    build(v, left(node), a, (a + b) / 2);
-    build(v, right(node), (a + b) / 2 + 1, b);
-    tree[node] = tree[node * 2] + tree[node * 2 + 1];
+    int mid = (a + b) / 2;
+    build(v, left(node), a, mid);
+    build(v, right(node), mid + 1, b);
+    tree[node] = tree[left(node)] + tree[right(node)];
   }
 
   /// Propagates value to tree and through lazy tree.
@@ -70,9 +71,10 @@ struct LazySegmentTree {
       return;
     }
 
-    update(i, j, val, left(node), a, (a + b) / 2);
-    update(i, j, val, right(node), (a + b) / 2 + 1, b);
-    tree[node] = tree[node * 2] + tree[node * 2 + 1];
+    int mid = (a + b) / 2;
+    update(i, j, val, left(node), a, mid);
+    update(i, j, val, right(node), mid + 1, b);
+    tree[node] = tree[left(node)] + tree[right(node)];
   }
 
   /// Returns sum of [i,j].
@@ -87,8 +89,9 @@ struct LazySegmentTree {
     if (a >= i && b <= j)
       return tree[node];
 
-    int q1 = query(i, j, left(node), a, (a + b) / 2);
-    int q2 = query(i, j, right(node), (a + b) / 2 + 1, b);
+    int mid = (a + b) / 2;
+    int q1 = query(i, j, left(node), a, mid);
+    int q2 = query(i, j, right(node), mid + 1, b);
     return q1 + q2;
   }
 };

algorithms/structure/segment_tree.cpp

@@ -6,11 +6,11 @@
 ///   Query  -> O(log n)
 /// Complexity (Space): O(n)
 
+int N;
 struct SegmentTree {
-  int N;
   vector<int> tree;
 
-  SegmentTree(int N, const vector<int> &v) : N(N), tree(N*4) {
+  SegmentTree(const vector<int> &v) : tree(MAX*4) {
     init();
     build(v);
   }
@@ -33,9 +33,10 @@ struct SegmentTree {
       return;
     }
 
-    build(v, left(node), a, (a + b) / 2);
-    build(v, right(node), 1 + (a + b) / 2, b);
-    tree[node] = tree[node * 2] + tree[node * 2 + 1];
+    int mid = (a + b) / 2;
+    build(v, left(node), a, mid);
+    build(v, right(node), mid + 1, b);
+    tree[node] = tree[left(node)] + tree[right(node)];
   }
 
   /// Updates position idx by adding value val.
@@ -50,9 +51,10 @@ struct SegmentTree {
       return;
     }
 
-    update(idx, val, left(node), a, (a + b) / 2);
-    update(idx, val, right(node), 1 + (a + b) / 2, b);
-    tree[node] = tree[node * 2] + tree[node * 2 + 1];
+    int mid = (a + b) / 2;
+    update(idx, val, left(node), a, mid);
+    update(idx, val, right(node), mid + 1, b);
+    tree[node] = tree[left(node)] + tree[right(node)];
   }
 
   /// Returns sum of [i,j].
@@ -64,8 +66,9 @@ struct SegmentTree {
     if (i <= a && b <= j) 
       return tree[node];
 
-    int q1 = query(i, j, left(node), a, (a + b) / 2);
-    int q2 = query(i, j, right(node), 1 + (a + b) / 2, b);
+    int mid = (a + b) / 2;
+    int q1 = query(i, j, left(node), a, mid);
+    int q2 = query(i, j, right(node), mid + 1, b);
     return q1 + q2;
   }
 };