update

Author: rishabhdeepsingh

Cpp/library/IO.hpp

@@ -1,21 +1,16 @@
 // doot diddly donger cuckerino Hahahahahah
 
 #pragma once
-//#pragma GCC optimize("Ofast")
-//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
-//#pragma GCC optimize("unroll-loops")
+#pragma GCC optimize("Ofast")
+#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
+#pragma GCC optimize("unroll-loops")
 
 #include <bits/stdc++.h>
-#include <ext/pb_ds/assoc_container.hpp>
-#include <ext/pb_ds/tree_policy.hpp>
-
-using namespace __gnu_pbds;
-using namespace __gnu_cxx;
 using namespace std;
 
 using ll = long long;
 using ld = long double;
-using pll = pair<ll, ll>;
+using pii = pair<int, int>;
 using vi = vector<int>;
 
 #define all(x)  (x).begin(), (x).end()

Cpp/library/collections/DSU.hpp

@@ -23,21 +23,25 @@ struct DSU {
     }
   }
 
+  bool same(int x, int y) {
+    return get(x) == get(y);
+  }
+  
   int get(int x) {
     return par[x] = (x == par[x]) ? x : get(par[x]);
   }
 
   bool unite(int x, int y) {
     x = get(x);
     y = get(y);
-    if (x == y) return true;
+    if (x == y) return false;
     if (rank[x] < rank[y]) swap(x, y);
     par[y] = x;
     if (heuristics == SIZE) {
       rank[x] += rank[y]; // Size use any one.
     } else {
       if (rank[x] == rank[y]) rank[x]++; // Rank Heuristics
     }
-    return false;
+    return true;
   }
 };

Cpp/library/generators.hpp

@@ -51,6 +51,34 @@ vector<T> randomVector(int n, T low, T high) {
   }
   return res;
 }
+
+template <typename T>
+vector<T> permutation(int n, int start = 0){
+  vector<T> res(n);
+  iota(res.begin(), res.end(), start);
+  return res;
+}
+
+template <typename T>
+vector<T> uniqueVector(int n, T low, T high) {
+  set<int> st;
+  uniform_int_distribution<T> distribution(low, high);
+  while ((int) st.size() != n) {
+    st.insert(distribution(rng));
+  }
+  return vector<T>(st.begin(), st.end());
+}
+
+template <typename T>
+set<T> randomSet(int n, T low, T high) {
+  set<int> st;
+  uniform_int_distribution<T> distribution(low, high);
+  while ((int) st.size() != n) {
+    st.insert(distribution(rng));
+  }
+  return st;
+}
+
 template <typename T>
 vector<vector<T>> randomMatrix(int n, int m, vector<T> vals) {
   vector<vector<T>> res(n, vector<T>(m, vals[0]));

Cpp/library/number/Mint.hpp

@@ -84,8 +84,8 @@ class Modular {
   template <typename U>
   friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
 
-  template <typename U>
-  friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
+  template <typename V, typename U>
+  friend V& operator>>(V& stream, Modular<U>& number);
 
 private:
   Type value;
@@ -135,14 +135,16 @@ string to_string(const Modular<T>& number) {
   return to_string(number());
 }
 
-template <typename T>
-std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
+// U == std::ostream? but done this way because of fastoutput
+template <typename U, typename T>
+U& operator<<(U& stream, const Modular<T>& number) {
   return stream << number();
 }
 
-template <typename T>
-std::istream& operator>>(std::istream& stream, Modular<T>& number) {
-  typename common_type<typename Modular<T>::Type, int64_t>::type x;
+// U == std::istream? but done this way because of fastinput
+template <typename U, typename T>
+U& operator>>(U& stream, Modular<T>& number) {
+  typename common_type<typename Modular<T>::Type, long long>::type x;
   stream >> x;
   number.value = Modular<T>::normalize(x);
   return stream;
@@ -157,5 +159,5 @@ ModType& md = VarMod::value;
 using Mint = Modular<VarMod>;
 */
 
-constexpr int md = 1e9 + 7;
+constexpr int md = (int) 1e9 + 7;
 using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;

Cpp/library/number/Sieve.hpp

@@ -4,12 +4,13 @@
 struct Sieve {
   int maxn;
 public:
+  using MapType = unordered_map<long long, long long>;
   std::vector<long long> spf;
   std::vector<long long> primes;
   std::vector<long long> mobius;
   std::vector<bool> isPrime;
 
-  Sieve(int _n = 2e6 + 7) : maxn(_n + 1) {
+  explicit Sieve(int _n = 2e6 + 7) : maxn(_n + 1) {
     spf.resize(maxn, 1);
     isPrime.resize(maxn, true);
     primes.clear();
@@ -78,8 +79,8 @@ struct Sieve {
     return ans;
   }
 
-  vector<pll> divisorPair(long long x) {
-    vector<pll> res;
+  vector<pair<long long, long long>> divisorPair(long long x) {
+    vector<pair<long long, long long>> res;
     for (long long i = 1; i * i <= x; i++) {
       if (x % i == 0) {
         if (x / i == i) {
@@ -92,9 +93,25 @@ struct Sieve {
     return res;
   }
 
-  map<long long, long long> primeFactors(long long val) {
+  set<long long> divisorSet(long long x) {
+    set<long long> res;
+    for (long long i = 1; i * i <= x; i++) {
+      if (x % i == 0) {
+        res.insert(i);
+        if (x / i != i) {
+          res.insert(x / i);
+        }
+      }
+    }
+    return res;
+  }
+  
+  MapType primeFactors(long long val) {
     if (val >= maxn) return primeFactorBrute(val);
-    map<long long, long long> fac;
+    static unordered_map<int, MapType> memo;
+    if(memo.count(val)) return memo[val];
+    long long temp = val;
+    MapType fac;
     while (val > 1) {
       int pf = spf[val];
       if (pf == 1) break;
@@ -105,11 +122,11 @@ struct Sieve {
       }
       fac[pf] = cnt;
     }
-    return fac;
+    return memo[temp] = fac;
   }
 
-  map<long long, long long> primeFactorBrute(long long val) {
-    map<long long, long long> mp;
+  MapType primeFactorBrute(long long val) {
+    MapType mp;
     while (val % 2 == 0) {
       mp[2]++;
       val /= 2;

Cpp/library/number/factorizer.hpp

@@ -54,17 +54,17 @@ bool IsPrime(T n, const vector<T>& bases) {
   return true;
 }
 
-bool IsPrime(int64_t n) {
+bool IsPrime(long long n) {
   return IsPrime(n, {2, 325, 9375, 28178, 450775, 9780504, 1795265022});
 }
 
 bool IsPrime(int32_t n) {
   return IsPrime(n, {2, 7, 61});
 }
 
-// but if you really need uint64_t version...
+// but if you really need unsigned long long version...
 /*
-bool IsPrime(uint64_t n) {
+bool IsPrime(unsigned long long n) {
   if (n < 2) {
     return false;
   }
@@ -81,9 +81,9 @@ bool IsPrime(uint64_t n) {
     return true;
   }
   uint32_t s = __builtin_ctzll(n - 1);
-  uint64_t d = (n - 1) >> s;
-  function<bool(uint64_t)> witness = [&n, &s, &d](uint64_t a) {
-    uint64_t cur = 1, p = d;
+  unsigned long long d = (n - 1) >> s;
+  function<bool(unsigned long long)> witness = [&n, &s, &d](unsigned long long a) {
+    unsigned long long cur = 1, p = d;
     while (p > 0) {
       if (p & 1) {
         cur = (__uint128_t) cur * a % n;
@@ -102,8 +102,8 @@ bool IsPrime(uint64_t n) {
     }
     return true;
   };
-  vector<uint64_t> bases_64bit = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
-  for (uint64_t a : bases_64bit) {
+  vector<unsigned long long> bases_64bit = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
+  for (unsigned long long a : bases_64bit) {
     if (a % n == 0) {
       return true;
     }
@@ -239,7 +239,7 @@ vector<pair<T, int>> Factorize(T x) {
     }
     return ret;
   }
-  if (x <= static_cast<int64_t>(precalculated) * precalculated) {
+  if (x <= static_cast<long long>(precalculated) * precalculated) {
     vector<pair<T, int>> ret;
     if (!IsPrime(x)) {
       for (T i : primes) {

Cpp/library/string/suffix_array.hpp

@@ -24,11 +24,12 @@ struct suffix_array {
 private:
   string s;
 public:
-  vector<int> p, c;
+  vector<int> p, c, lcp;
   int n;
   // strings are s.substr(p[i], n - p[i]);
 
-  explicit suffix_array(string  _s) : s(std::move(_s)) {
+  explicit suffix_array(string _s) : s(std::move(_s)) {
+    lcp.clear();
     s += "$";
     n = (int) s.length();
     // Ordering and Equivalence classes
@@ -51,7 +52,7 @@ struct suffix_array {
     }
     for (int k = 0; ((1ll << k) < n); ++k) {
       for (int i = 0; i < n; ++i) {
-        p[i] = (p[i] - (1 << k) + n) % n;
+        p[i] = (p[i] - (1ll << k) + n) % n;
       }
       count_sort(p, c);
       vector<int> c_new(n, 0);
@@ -75,16 +76,9 @@ struct suffix_array {
     return s.substr(p[i], n - 1 - p[i]);
   }
 
-  vector<string> allSubs() {
-    vector<string> res;
-    for (int i = 0; i < n; ++i) {
-      res.push_back(sub(i));
-    }
-    return res;
-  }
-  
-  vector<int> lcp() {
-    vector<int> lcp(n, 0);
+  vector<int> build_lcp() {
+    if (!lcp.empty()) return lcp;
+    lcp = vector<int>(n, 0);
     int k = 0;
     for (int i = 0; i < n - 1; ++i) {
       int pi = c[i]; // Pos of suffix i in suffix array
@@ -98,6 +92,27 @@ struct suffix_array {
     return lcp;
   }
 
+  long long countDistinct() {
+    build_lcp();
+    long long result = 0;
+    for (int i = 0; i < lcp.size(); i++)
+      result += (n - 1 - p[i]) - lcp[i];
+    return result;
+  }
+  
+  int operator[](int index) const {
+    return p[index];
+  }
+  
+  // Returns all the substrings of the given string
+  vector<string> allSubs() {
+    vector<string> res;
+    for (int i = 0; i < n; ++i) {
+      res.push_back(sub(i));
+    }
+    return res;
+  }
+  
   int count(const string& sub) {
     int high = upper(sub);
     int low = lower(sub);