Merge pull request #23 from r6mez/main

adding stuff

Author: r6mez

content/contest/template.cpp

@@ -11,9 +11,8 @@ void solve() {
 signed main() {
   cin.tie(nullptr)->sync_with_stdio(false);
   int t = 1;
-  cin >> t;
-  while (t--)
-    solve();
+  // cin >> t;
+  while (t--) solve();
   return 0;
 }
 

content/data-structures/BinaryTrie.cpp

@@ -0,0 +1,56 @@
+/**
+ * Author: Ramez
+ * Description: binary trie that supports update(val, op),
+ * where op = +1 to insert, op = –1 to erase and query(x) → ans is the maximum XOR you can
+ * achieve between x and any value currently in the trie.
+ * Time: $O(1)$ time, $O(N)$ space
+ */
+
+struct node {
+    int ch[2]{}, frq[2]{}, sz{};
+
+    int& operator[](int x) {
+        return ch[x];
+    }
+};
+
+const int M = 60;
+
+struct BinaryTrie {
+    vector<node> nodes;
+
+    int newNode() { return nodes.emplace_back(), nodes.size() - 1; }
+
+    void init() { nodes.clear(), newNode(); }
+
+    BinaryTrie() { init(); }
+
+    void update(int val, int op) { /// 1 -> add , -1 -> delete
+        int u = 0;
+        for (int i = M - 1; i >= 0; --i) {
+            int v = val >> i & 1;
+            if (!nodes[u][v]) {
+                nodes[u][v] = newNode();
+            }
+            nodes[u].frq[v] += op;
+            nodes[u].sz += op;
+            u = nodes[u][v];
+        }
+        nodes[u].sz++;
+    }
+
+    int query(int x) {
+        int ans = 0, u = 0;
+        for (int i = M - 1; i >= 0 && u >= 0; --i) {
+            int v = x >> i & 1;
+            if (nodes[u].frq[v]) {
+                u = nodes[u][v];
+            }
+            else {
+                u = nodes[u][!v];
+                ans |= 1LL << i;
+            }
+        }
+        return ans;
+    }
+};

content/data-structures/DSU.h

@@ -1,8 +1,5 @@
 /**
- * Author: Lukas Polacek
- * Date: 2009-10-26
- * License: CC0
- * Source: folklore
+ * Author: Ramez
  * Description: Disjoint-set data structure.
  * Time: $O(\alpha(N))$
  */

content/data-structures/FenwickRUPQ.cpp

@@ -0,0 +1,26 @@
+/**
+ * Author: Ramez Medhat
+ * Description: Range Update, Point Query
+ * Time: O(logN)
+ */
+struct FenwickRUPQ {
+    int n;
+    vi f;
+    FenwickRUPQ(int _n) : n(_n), f(n + 1, 0) {}
+
+    void update(int idx, int val) {
+        for (; idx <= n; idx += idx & -idx)
+            f[idx] += val;
+    }
+
+    void rangeAdd(int l, int r, int val) {
+        update(l, val);
+        if (r + 1 <= n) update(r + 1, -val);
+    }
+
+    int pointQuery(int idx) {
+        int res = 0;
+        for (; idx > 0; idx -= idx & -idx) res += f[idx];
+        return res;
+    }
+};

content/data-structures/SubMatrix.h content/data-structures/PrefixSum2D.hcontent/data-structures/SubMatrix.h renamed to content/data-structures/PrefixSum2D.h

@@ -13,13 +13,13 @@
 #pragma once
 
 template<class T>
-struct SubMatrix {
+struct PrefixSum2D {
 	vector<vector<T>> p;
-	SubMatrix(vector<vector<T>>& v) {
-		int R = sz(v), C = sz(v[0]);
-		p.assign(R+1, vector<T>(C+1));
-		rep(r,0,R) rep(c,0,C)
-			p[r+1][c+1] = v[r][c] + p[r][c+1] + p[r+1][c] - p[r][c];
+	PrefixSum2D(vector<vector<T>>& v) {
+		int R = v.size(), C = v[0].size();
+		p.assign(R + 1, vector<T>(C + 1));
+		for (int r = 0; r < R; r++) for (int c = 0; c < C; c++)
+			p[r + 1][c + 1] = v[r][c] + p[r][c + 1] + p[r + 1][c] - p[r][c];
 	}
 	T sum(int u, int l, int d, int r) {
 		return p[d][r] - p[d][l] - p[u][r] + p[u][l];

content/data-structures/Trie.cpp

@@ -0,0 +1,70 @@
+/**
+ * Author: Ramez
+ * Description: Trie
+ * Time: $O(1)$ time, $O(N)$ space
+ */
+
+struct Trie {
+    struct Node {
+        Node* child[26];
+        int IsEnd, Prefix;
+        Node() {
+            memset(child, 0, sizeof child);
+            IsEnd = Prefix = 0;
+        }
+    };
+
+    Node* root = new Node();
+    
+    void insert(string& s)
+    {
+        Node* cur = root;
+        for (auto it : s)
+        {
+            int idx = it - 'a';
+            if (cur->child[idx] == 0)
+            {
+                cur->child[idx] = new Node();
+            }
+            cur = cur->child[idx];
+            cur->Prefix++;
+        }
+        cur->IsEnd++;
+    }
+    
+    bool searchWord(string& s)
+    {
+        Node* cur = root;
+        for (auto it : s)
+        {
+            int idx = it - 'a';
+            if (cur->child[idx] == 0)return 0;
+            cur = cur->child[idx];
+        }
+        return cur->IsEnd;
+    }
+    
+    int countWord(string& s)
+    {
+        Node* cur = root;
+        for (auto it : s)
+        {
+            int idx = it - 'a';
+            if (cur->child[idx] == 0)return 0;
+            cur = cur->child[idx];
+        }
+        return cur->IsEnd;
+    }
+    
+    int countPrefix(string& s)
+    {
+        Node* cur = root;
+        for (auto it : s)
+        {
+            int idx = it - 'a';
+            if (cur->child[idx] == 0)return 0;
+            cur = cur->child[idx];
+        }
+        return cur->Prefix;
+    }
+};

content/data-structures/chapter.tex

@@ -3,17 +3,24 @@ \chapter{Data structures}
 \kactlimport{LazySegmentTree.h}
 \kactlimport{MergeSortTree.h}
 \kactlimport{FenwickPURQ.cpp}
+\kactlimport{FenwickRUPQ.cpp}
 \kactlimport{FenwickRURQ.cpp}
 \kactlimport{Fenwick2d.h}
 \kactlimport{Fenwick2dAdd.h}
 \kactlimport{Fenwick2dXor.h}
 \kactlimport{OrderStatisticTree.h}
 \kactlimport{HashMap.h}
+\kactlimport{LazySegmentTree.h}
 \kactlimport{DSU.h}
 \kactlimport{DSURollback.h}
-\kactlimport{SubMatrix.h}
+\kactlimport{PrefixSum2D.h}
 \kactlimport{Matrix.h}
 \kactlimport{LineContainer.h}
 \kactlimport{Treap.h}
 \kactlimport{RMQ.h}
 \kactlimport{MoQueries.h}
+\kactlimport{MergeSortTree.h}
+\kactlimport{Trie.cpp}
+\kactlimport{BinaryTrie.cpp}
+
+

content/number-theory/Combinatorics.cpp

@@ -0,0 +1,62 @@
+/**
+ * Author: Ramez 
+ * Description: Function to solve combinatorics problems.
+ * Time: O(n) for init and O(1) for query
+ */
+
+namespace combinatorics {
+    vector<int> fact, inv, invFact;
+
+    int pwmod(int a, int b) {
+        a %= MOD;
+        int result = 1;
+        while (b > 0) {
+            if (b & 1) result = (result * a) % MOD;
+            a = (a * a) % MOD;
+            b /= 2;
+        }
+        return result;
+    }
+
+    int inverse(int x) { return pwmod(x, MOD - 2); }
+    int multiply(int a, int b) { return ((a % MOD) * (b % MOD)) % MOD; }
+    int divide(int a, int b) { return multiply(a, inverse(b)); }
+
+    void init(int n) {
+        fact.resize(n + 1); inv.resize(n + 1); invFact.resize(n + 1);
+        fact[0] = fact[1] = inv[0] = inv[1] = invFact[0] = invFact[1] = 1; 
+        for (int i = 2; i <= n; ++i){
+            fact[i] = fact[i - 1] * i % MOD;
+            inv[i] = MOD - ((MOD / i) * inv[MOD % i]) % MOD;
+            invFact[i] = invFact[i - 1] * inv[i] % MOD;
+        } 
+    }
+
+    int nPr(int n, int r) {
+        if (n < 0 || r < 0 || r > n) return 0;
+        return fact[n] * invFact[n - r] % MOD;
+    }
+
+    int nCr(int n, int r) {
+        if (n < 0 || r < 0 || r > n) return 0;
+        return fact[n] * invFact[r] % MOD * invFact[n - r] % MOD;
+    }
+
+    int nPrLinear(int n, int r){
+        int answer = 1;
+        for (int i = n - r + 1; i <= n; i++){
+            answer = multiply(answer, i);
+        }
+        return answer;
+    }
+
+    int nCrLinear(int n, int r){
+        int answer = 1;
+        for (int i = r + 1; i <= n; i++){
+            answer = multiply(answer, i);
+            answer = divide(answer, i - r);
+        }
+        return answer;
+    }
+};
+using namespace combinatorics;

content/number-theory/FastEratosthenes.h content/number-theory/FastSieve.hcontent/number-theory/FastEratosthenes.h renamed to content/number-theory/FastSieve.h

@@ -37,3 +37,4 @@ vi eratosthenes() {
 	for (int i : pr) isPrime[i] = 1;
 	return pr;
 }
+

content/number-theory/IsPrime.cpp

@@ -0,0 +1,16 @@
+/**
+ * Author: Ramez Medhat
+ * Description: Checks if a number is prime or not
+ * Time: $O(\sqrt{n})$
+ * Status: Tested
+ */
+
+
+bool isPrime(int n) {
+    if (n == 2) return true;
+    if (n == 1 || n % 2 == 0) return false;
+    for (int i = 3; i * i <= n; i += 2) {
+        if (n % i == 0) return false;
+    }
+    return true;
+}