Add some stuf :\

Author: mehranagh20

data_structure/hld.cpp

@@ -0,0 +1,72 @@
+const int N = 1e4 + 10; // max of nodes
+int n;
+vvii g[N]; // the tree
+ll nxt[N], depth[N], tt, sz[N], in[N], out[N], rin[N], p[N];
+int cst2[N + 10];
+
+// some segment tree code here!
+
+void dfs_sz(int v = 0, int par = 0, int dpth = 0) {
+ sz[v] = 1, p[v] = par, depth[v] = dpth;
+ for (auto &u: g[v]) {
+ if (u.first != par) {
+ dfs_sz(u.first, v, dpth + 1);
+ sz[v] += sz[u.first];
+ if (sz[u.first] > sz[g[v][0].first])
+ swap(u, g[v][0]);
+ }
+ }
+}
+
+// nxt[x] ==> head of segment which x belongs to
+// [in[nxt[v]], in[v]] ==> path from head of path which contains 'v' to 'v'
+// [in[v], out[v]) == > subtree of 'v', pay attention to right )
+void dfs_hld(int v = 0, int par = 0, int cst = -inf) { // change cst in case of other operations if needed
+ in[v] = tt++;
+ rin[in[v]] = v;
+
+ // modify in case of vertex query!
+ cst2[in[v]] = cst; // setting cost of this edge(par --> v) in array which segment tree build is called upon it
+ for (auto u: g[v]) {
+ if (u.first != par) {
+ nxt[u.first] = (u.first == g[v][0].first ? nxt[v] : u.first);
+ dfs_hld(u.first, v, u.second);
+ }
+ }
+ out[v] = tt;
+}
+
+ll crawl(ll u, ll v) { // path query
+ ll ans = -1000000000LL; // we want max of a path, so we initialize this way
+ while (nxt[u] != nxt[v]) {
+ if (depth[nxt[u]] < depth[nxt[v]]) swap(u, v);
+ ans = max(ans, go(1, 0, n - 1, in[nxt[u]], in[u])); // go is get function of segment tree
+ u = p[nxt[u]];
+ }
+ if (in[v] > in[u]) swap(v, u);
+ return max(ans, go(1, 0, n - 1, in[v] + 1, in[u])); // in case of node queries remove +1 because even the head matters
+}
+
+void modify(int a, int b) { // modify node or edge 'a' to value 'b'
+ upd(1, 0, n - 1, in[a], b); // segment tree update
+}
+
+int main() {
+ // get input here ...
+ dfs_sz();
+ dfs_hld();
+ build(1, 0, n - 1); // build segment tree for tree with n nodes
+
+ // query part:
+ // ask query, one based
+ int a, b; cin >> a >> b; a--, b--;
+ cout << crawl(a, b) << endl;
+
+ // update a'th edge to 'b'
+ cin >> a >> b; a--;
+ // if query is on nodes, then just use the actual node to update
+ int u = edges[a].first, v = edges[a].second;
+ // we assume the node with higher depth to be representative of the edge
+ if (depth[u] > depth[v]) modify(u, b); // depth is valued after running dfs
+ else modify(v, b);
+}

data_structure/seg_tree_lazy_update.cpp

@@ -1,64 +1,53 @@
 vi arr, t, lazy; // arr is numbers to build seg tree with, if its size is 'n' then t and lazy size should be 4 * n (2 * n)
 
-void build(int node, int a, int b) // call build(1, 0, n - 1) for n elements
-{
- if(a>b) return;
- if (a==b)
- {
- t[node]=arr[a];
- return;
+void build(int node, int a, int b){ // call build(1, 0, n - 1) for n elements
+ if(a > b) return;
+ if (a == b){
+ t[node] = arr[a]; return; 
  }
 
  build(node*2, a, (a+b)/2);
  build(node*2+1,(a+b)/2+1,b);
 
- t[node]=t[node*2]+t[node*2+1]; // update here in case of change of operation, for example min
+ t[node] = t[node * 2] + t[node * 2+1]; // update here in case of change of operation, for example min
 }
 
-ull query(int node, int a, int b, int i, int j) // call query(1, 0, n - 1, i, j) to get query of i..j for seg tree of n elements
-{
- if(a>b||a>j||b<i) return 0;
- if (lazy[node] !=0 )
- {
+ull query(int node, int a, int b, int i, int j){ // call query(1, 0, n - 1, i, j) to get query of i..j for seg tree of n elements
+ if(a>b || a>j || b<i) return 0;
+ if (lazy[node] !=0 ){
  t[node]+=lazy[node]*(b-a+1); // it is possible to update the tree in ways other that increasing a range.
  // for example it is possible to change all the elements of a range to a number, for example all numbers in range of i..j to 11
  // just underestand the way lazy works and change lazy arr value and interaction between lazy and real tree array, like t[node] = lazy[node] * (b - a + 1)
- if (a!=b)
- {
- lazy[node*2]+=lazy[node];
- lazy[node*2+1]+=lazy[node];
+ if (a!=b){
+ lazy[node*2] += lazy[node];
+ lazy[node*2+1] += lazy[node];
  }
  lazy[node]=0;
  }
 
- if (a>=i && b<=j) return t[node];
+ if (a >= i && b <= j) return t[node];
 
  ull q1=query(node*2, a, (a+b)/2, i, j);
  ull q2=query(node*2+1, (a+b)/2+1, b, i, j);
 
- return q1+q2; // update here in case of change of operation, for example min
+ return q1 + q2; // update here in case of change of operation, for example min
 }
 
-void update(int node, int a, int b, int i, int j, int inc)
-{
- if(a>b) return;
- if (lazy[node]!=0)
- {
- t[node]+=lazy[node]*(b-a+1);
- if (a!=b)
- {
+void update(int node, int a, int b, int i, int j, int inc){
+ if(a > b) return;
+ if (lazy[node] !=0) {
+ t[node] += lazy[node] * (b-a+1);
+ if (a!=b) {
  lazy[node*2]+=lazy[node];
  lazy[node*2+1]+=lazy[node];
  }
- lazy[node]=0;
+ lazy[node] = 0;
  }
- if(a>b||a>j||b<i) return;
+ if(a>b || a>j || b<i) return;
 
- if (a>=i && b<=j)
- {
+ if (a >= i && b <= j){
  t[node]+=inc*(b-a+1);
- if (a!=b)
- {
+ if (a!=b){
  lazy[node*2]+=inc;
  lazy[node*2+1]+=inc;
  }

handy-algorithms/mu.explain

@@ -0,0 +1,6 @@
+mu[i] = {0 if i contains a prime more than once
+ 1 if i consists of even number of primes
+ -1 otherwise, ie. odd number of primes}
+mu can be used to count number of things with gcd of 1 using inclution exclution
+to do this: sigma_over_possible_j_as_product_of_primes(mu[j] * f(j))
+where f(j) returns number of things where their gcd is divisible by every elemnt of j's factorization, ie. 'j'.

mathematics/number-theory.md

@@ -1,7 +1,3 @@
-# Number Theory
-
-### Prime Numbers
-
 // Linear sieve, change it to use bitset instead
 // runs in O(n) since it crosses the composite numbers exactly once
 std::vector <int> prime;
@@ -18,218 +14,11 @@ void sieve (int n) {
 }
 }
 
-**Sieve of Eratosthenes**: to generate list of prime numbers
-* O(n log log n): `n = 1e7`
-**Prime checker**
-* O(1) for `n <= sieve_size` and O(sqrt(n) / ln sqrt(n)) for bigger `n`s.
-
-
-```cpp
-#include <bitset>
-
-ll sieve_size;
-bitset<10000010> bs; // 10^7 should be enough for most cases
-vi primes;
-
- // create list of primes in [0..upperbound]
-void sieve(ll upperbound) {
- sieve_size = upperbound + 1; // add 1 to include upperbound
- bs.set(); // set all bits to 1
- bs[0] = bs[1] = 0; // except index 0 and 1
- for (ll i = 2; i <= sieve_size; i++)
- if (bs[i]) {
- // cross out multiples of i starting from i * i!
- for (ll j = i * i; j <= sieve_size; j += i) bs[j] = 0;
- primes.push_back(i);
- }
-}
-
-bool isPrime(ll n) {
- if (n <= sieve_size) return bs[n];
- for (int i = 0; i < primes.size(); i++)
- if (n % primes[i] == 0) return false;
- return true;
-} // note: only work for n <= (last prime in vi "primes")^2
-
-// inside main()
-sieve(10000000); // can go up to 10^7 (need few seconds)
-```
-
-### GCD and LCM
-
-* O(log10 n): `n = max(a, b)`
-
-```cpp
-int gcd(int a, int b) {
- return b == 0 ? a : gcd(b, a % b);
-}
-int lcm(int a, int b) {
- return a * (b / gcd(a, b));
-}
-```
-
-### Factorial
-
-* O(n)
-
-```cpp
-// ll can hold up to fact(20); for beyond use Java BigInteger
-ll fact(int n) {
- return n == 0 ? 1 : n * fact(n - 1);
-}
-```
-
-### Prime-Power Factorization
-
-* O(sqrt(n) / ln sqrt(n))
-
-```cpp
-// needs sieve of eratosthenes
-vi primeFactors(ll n) {
- vi factors;
- ll PF_idx = 0, PF = primes[PF_idx];
- while (PF * PF <= n) {
- while (n % PF == 0) {
- n /= PF;
- factors.push_back(PF);
- } 
- PF = primes[++PF_idx];
- }
- if (n != 1) factors.push_back(n); // special case if n is a prime
- return factors;
-}
-
-// inside int main(), assuming sieve(1000000) has been called before
-vi r = primeFactors(2147483647);
-```
-
-### Functions involving prime numbers
-
-* `numPF(n)`: Count the number of prime factors of `n`
-
 ```cpp
-ll numPF(ll n) {
- ll PF_idx = 0, PF = primes[PF_idx], ans = 0;
- while (PF * PF <= n) {
- while (n % PF == 0) {
- n /= PF;
- ans++;
- }
- PF = primes[++PF_idx];
+long long gcd(long long a, long long b) {
+ while (a > 0 && b > 0) {
+ if (a > b) a %= b;
+ else b %= a;
  }
- if (n != 1) ans++;
- return ans;
-}
-```
-
-* `numDiffPF(n)`: Count the number of *different* prime factors of `n`
-
-```cpp
-ll numDiffPF(ll n) {
- ll PF_idx = 0, PF = primes[PF_idx], ans = 0;
- while (PF * PF <= n) {
- int power = 0;
- while (n % PF == 0) {
- n /= PF;
- power++;
- }
- if (power)
- ans++;
- PF = primes[++PF_idx];
- }
- if (n != 1) ans++;
- return ans;
-}
-```
-
-* `numDiv(n)`: Count the number of *divisors* of `n`
-
-```cpp
-ll numDiv(ll n) {
- ll PF_idx = 0, PF = primes[PF_idx], ans = 1;
- while (PF * PF <= n) {
- ll power = 0;
- while (n % PF == 0) {
- n /= PF;
- power++;
- }
- ans *= power + 1;
- PF = primes[++PF_idx];
- }
- if (n != 1) ans *= 2; // last factor has pow = 1, we add 1 to it
- return ans;
-}
-```
-
-* `sumDiv(n)`: Sum of divisors of `n`
-
-```cpp
-ll sumDiv(ll n) {
- ll PF_idx = 0, PF = primes[PF_idx], ans = 1;
- while (PF * PF <= n) {
- ll power = 0;
- while (n % PF == 0) {
- n /= PF;
- power++;
- }
- ans *= ((ll)pow((double)PF, power + 1.0) - 1) / (PF - 1);
- PF = primes[++PF_idx];
- }
- if (n != 1) ans *= ((ll)pow((double)n, 2.0) - 1) / (n - 1); // last
- return ans;
-}
-```
-
-* `EulerPhi(n)`: Count the number of positive integers < `n` that are relatively prime to `n`
-
-The formula is: `phi(n) = n * PI (1 - 1/PF) for PF = prime factors of n`
-
-```cpp
-ll EulerPhi(ll n) {
- ll PF_idx = 0, PF = primes[PF_idx], ans = n;
- while (PF * PF <= n) {
- if (n % PF == 0) ans -= ans / PF;
- while (n % PF == 0) n /= PF;
- PF = primes[++PF_idx];
- }
- if (n != 1) ans -= ans / n;
- return ans;
-}
-```
-
-### Modified Sieve
-
-Used when there are many numbers to determine `numDiffPF` for them
-
-```cpp
-vi numDiffPF(MAX_N, 0);
-
-for (int i = 2; i < MAX_N; i++)
- if (numDiffPF[i] == 0) // i is a prime number
- for (int j = i; j < MAX_N; j += i)
- numDiffPF[j]++; // increase the values of multiples of
-```
-
-### Extended Euclid: Solving Linear Diophantine Equation
-
-Suppose we have `ax + by = c` and `d = gcd(a, b)`. 
-If `d | c` is not true then there is no integral solutions. 
-Otherwise the first solution `(x0, y0)` can be found using **Extended Euclid**.
-Then other solutions can be derived from `x = x0 + (b/d)n` and `y = y0 - (a/d)n`.
-
-```cpp
-// store x, y, and d as global variables
-void extendedEuclid(int a, int b) {
- if (b == 0) {
- x = 1;
- y = 0;
- d = a;
- return;
- } // base case
- extendedEuclid(b, a % b); // similar as the original gcd
- int x1 = y;
- int y1 = x - (a / b) * y;
- x = x1;
- y = y1;
+ return a + b;
 }
-```