Small fixes

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

algorithms/graph/kruskal.cpp

@@ -28,9 +28,6 @@ struct Kruskal {
     });
 
     int size = 0;
-    for (int i = 0; i < N; i++)
-      ds.make_set(i);
-
     for (int i = 0; i < edges.size(); i++) {
       int pu = ds.find_set(edges[i].fi.fi);
       int pv = ds.find_set(edges[i].fi.se);

algorithms/math/big_integer.cpp

@@ -50,7 +50,7 @@ struct BigInt {
     return ans;
   }
 
-  /// Remove leading zeros.
+  // Removes leading zeros.
   void trim() {
     while (!num.empty() && num.back() == 0)
       num.pop_back();
@@ -83,21 +83,21 @@ struct BigInt {
   bool operator!=(const BigInt &x) const { return !(*this == x); }
 
 
-  /// Handles -x (change of sign).
+  // Handles -x (change of sign).
   BigInt operator-() const {
     BigInt ans = *this;
     ans.sign = -sign;
     return ans;
   }
 
-  /// Returs absolute value.
+  // Returs absolute value.
   BigInt abs() const {
     BigInt ans = *this;
     ans.sign *= ans.sign;
     return ans;
   }
 
-  /// Transforms string into BigInt.
+  // Transforms string into BigInt.
   void read(const string &s) {
     sign = 1;
     num.clear();
@@ -139,7 +139,7 @@ struct BigInt {
     return stream;
   }
 
-  /// Handles vector operations.
+  // Handles vector operations.
   int back() const { return num.back(); }
   bool empty() const { return num.empty(); }
   size_t size() const { return num.size(); }

algorithms/math/modular_multiplicative_inverse.cpp

@@ -3,20 +3,20 @@
 /// Time: O(log m)
 /// Space: O(1)
 
-// ============= Fermat's Little Theorem ============
-// Used when m is prime
+struct ModMultInv {
 
-int mod_inverse(int a, int m) {
-  BinaryExponentiation bin_exp;
-  return bin_exp.run(a, m - 2);
-}
+  // Fermat's Little Theorem: Used when m is prime
+  int fermat(int a, int m) {
+    BinaryExponentiation bin_exp;
+    return bin_exp.run(a, m - 2);
+  }
 
-// ========== Extended Euclidean Algorithm ==========
-// Used when m and a are coprime
-
-int mod_inverse(int a, int m) {
-  ExtendedEuclidean ext_gcd;
-  int x, y;
-  int g = ext_gcd.run(a, m, x, y);
-  return (x % m + m) % m;
-}
+  // Extended Euclidean Algorithm: Used when m 
+  // and a are coprime
+  int extended_euclidean(int a, int m) {
+    ExtendedEuclidean ext_gcd;
+    int x, y;
+    int g = ext_gcd.run(a, m, x, y);
+    return (x % m + m) % m;
+  }
+};