Merge pull request #92 from inzva/muratbiberoglu-patch

Migration of bundles continue

Author: muratbiberoglu

docs/data-structures/img/mo.png

@@ -22,12 +22,14 @@ Bilgisayar biliminde veri yapıları, belirli bir eleman kümesi üzerinde verim
 ### [Deque](deque.md)
 ### [Fenwick Tree](fenwick-tree.md)
 ### [Segment Tree](segment-tree.md)
+### [Trie](trie.md)
 
 ## Statik Veri Yapıları
 
 ### [Prefix Sum](prefix-sum.md)
 ### [Sparse Table](sparse-table.md)
 ### [SQRT Decomposition](sqrt-decomposition.md)
+### [Mo's Algorithm](mo-algorithm.md)
 
 ## Common Problems
 

docs/data-structures/img/trie.png

@@ -0,0 +1,114 @@
+---
+title: Mo's Algorithm
+tags:
+    - Data Structures
+    - Mo's Algorithm
+---
+
+This method will be a key for solving offline range queries on an array. By offline, we mean we can find the answers of these queries in any order we want and there are no updates. Let’s introduce a problem and construct an efficient solution for it.
+
+You have an array a with $N$ elements such that it’s elements ranges from $1$ to $M$. You have to answer $Q$ queries. Each is in the same type. You will be given a range $[l, r]$ for each query, you have to print how many different values are there in the subarray $[a_l , a_{l+1}..a_{r−1}, a_r]$.
+
+First let’s find a naive solution and improve it. Remember the frequency array we mentioned before. We will keep a frequency array that contains only given subarray’s values. Number of values in this frequency array bigger than 0 will be our answer for given query. Then we have to update frequency array for next query. We will use $\mathcal{O}(N)$ time for each query, so total complexity will be $\mathcal{O}(Q \times N)$. Look at the code below for implementation.
+
+```cpp
+class Query {
+   public:
+    int l, r, ind;
+    Query(int l, int r, int ind) {
+        this->l = l, this->r = r, this->ind = ind;
+    }
+};
+
+void del(int ind, vector<int> &a, vector<int> &F, int &num) {
+    if (F[a[ind]] == 1) num--;
+    F[a[ind]]--;
+}
+
+void add(int ind, vector<int> &a, vector<int> &F, int &num) {
+    if (F[a[ind]] == 0) num++;
+    F[a[ind]]++;
+}
+
+vector<int> solve(vector<int> &a, vector<Query> &q) {
+    int Q = q.size(), N = a.size();
+    int M = *max_element(a.begin(), a.end());
+    vector<int> F(M + 1, 0);  // This is frequency array we mentioned before
+    vector<int> ans(Q, 0);
+    int l = 0, r = -1, num = 0;
+    for (int i = 0; i < Q; i++) {
+        int nl = q[i].l, nr = q[i].r;
+        while (l < nl) del(l++, a, F, num);
+        while (l > nl) add(--l, a, F, num);
+        while (r > nr) del(r--, a, F, num);
+        while (r < nr) add(++r, a, F, num);
+        ans[q[i].ind] = num;
+    }
+    return ans;
+}
+```
+
+Time complexity for each query here is $\mathcal{O}(N)$. So total complexity is $\mathcal{O}(Q \times N)$. Just by changing the order of queries we will reduce this complexity to $\mathcal{O}((Q + N) \times \sqrt N)$.
+
+## Mo's Algorithm
+
+We will change the order of answering the queries such that overall complexity will be reduced drastically. We will use following cmp function to sort our queries and will answer them in this sorted order. Block size here is $\mathcal{O}(\sqrt N)$.
+
+```cpp
+bool operator<(Query other) const {
+    return make_pair(l / block_size, r) <
+        make_pair(other.l / block_size, other.r);
+}
+```
+
+Why does that work? Let’s examine what we do here first then find the complexity. We divide $l$'s of queries into blocks. Block number of a given $l$ is $l$ blocksize (integer division). We sort the queries first by their block numbers then for same block numbers, we sort them by their $r$'s. Sorting all queries will take $\mathcal{O}(Q \times log{Q})$ time. Let’s look at how many times we will call add and del operations to change current $r$. For the same block $r$'s always increases. So for same block it is $\mathcal{O}(N)$ since it can only increase. Since there are $N$ blocksize blocks in total, it will be $\mathcal{O}(N \times N / \text{block\_size})$ operations in total. For same block, add and del operations that changes $l$ will be called at most $\mathcal{O}(\text{block\_size})$ times for each query, since if block number is same then their $l$'s must differ at most by $\mathcal{O}(\text{block\_size})$. So overall it is $\mathcal{O}(Q \times \text{block\_size})$. Also when consecutive queries has different block numbers we will perform at most $\mathcal{O}(N)$ operations, but notice that there are at most $\mathcal{O}(N \div \text{block\_size})$ such consecutive queries, so it doesn't change the overall time complexity. If we pick $block\_size = \sqrt N$ overall complexity will be $\mathcal{O}((Q + N) \times \sqrt N)$. Full code is given below.
+
+<figure markdown="span" style="width: 64%">
+![Example for the Algorithm](img/mo.png)
+<figcaption>Example for the Algorithm</figcaption>
+</figure>
+
+```cpp
+int block_size;
+
+class Query {
+   public:
+    int l, r, ind;
+    Query(int l, int r, int ind) {
+        this->l = l, this->r = r, this->ind = ind;
+    }
+    bool operator<(Query other) const {
+        return make_pair(l / block_size, r) <
+               make_pair(other.l / block_size, other.r);
+    }
+};
+
+void del(int ind, vector<int> &a, vector<int> &F, int &num) {
+    if (F[a[ind]] == 1) num--;
+    F[a[ind]]--;
+}
+
+void add(int ind, vector<int> &a, vector<int> &F, int &num) {
+    if (F[a[ind]] == 0) num++;
+    F[a[ind]]++;
+}
+
+vector<int> solve(vector<int> &a, vector<Query> &q) {
+    int Q = q.size(), N = a.size();
+    int M = *max_element(a.begin(), a.end());
+    block_size = sqrt(N);
+    sort(q.begin(), q.end());
+    vector<int> F(M + 1, 0);  // This is frequency array we mentioned before
+    vector<int> ans(Q, 0);
+    int l = 0, r = -1, num = 0;
+    for (int i = 0; i < Q; i++) {
+        int nl = q[i].l, nr = q[i].r;
+        while (l < nl) del(l++, a, F, num);
+        while (l > nl) add(--l, a, F, num);
+        while (r > nr) del(r--, a, F, num);
+        while (r < nr) add(++r, a, F, num);
+        ans[q[i].ind] = num;
+    }
+    return ans;
+}
+```

docs/data-structures/index.md

@@ -0,0 +1,66 @@
+---
+title: Trie
+tags:
+    - Data Structures
+    - Trie
+---
+
+Trie is an efficient information reTrieval data structure. Using Trie, search complexities can be brought to optimal limit (key length). If we store keys in binary search tree, a well balanced BST will need time proportional to $M \times log N$, where $M$ is maximum string length and $N$ is number of keys in tree. Using Trie, we can search the key in $\mathcal{O}(M)$ time. However the penalty is on Trie storage requirements (Please refer [Applications of Trie](https://www.geeksforgeeks.org/advantages-trie-data-structure/) for more details)
+
+
+<figure markdown="span" style="width: 36%">
+![Trie Structure https://www.geeksforgeeks.org/wp-content/uploads/Trie.png](img/trie.png)
+<figcaption>Trie Structure. https://www.geeksforgeeks.org/wp-content/uploads/Trie.png</figcaption>
+</figure>
+
+Every node of Trie consists of multiple branches. Each branch represents a possible character of keys. We need to mark the last node of every key as end of word node. A Trie node field isEndOfWord is used to distinguish the node as end of word node. A simple structure to represent nodes of English alphabet can be as following,
+
+```cpp
+// Trie node
+class TrieNode {
+   public:
+    TrieNode *children[ALPHABET_SIZE];
+    bool isEndOfWord;
+    TrieNode() {
+        isEndOfWord = false;
+        for (int i = 0; i < ALPHABET SIZE; i++)
+            children[i] = NULL;
+    }
+};
+```
+
+## Insertion
+
+Inserting a key into Trie is simple approach. Every character of input key is inserted as an individual Trie node. Note that the children is an array of pointers (or references) to next level Trie nodes. The key character acts as an index into the array children. If the input key is new or an extension of existing key, we need to construct non-existing nodes of the key, and mark end of word for last node. If the input key is prefix of existing key in Trie, we simply mark the last node of key as end of word. The key length determines Trie depth.
+
+```cpp
+void insert(struct TrieNode *root, string key) {
+    struct TrieNode *pCrawl = root;
+    for (int i = 0; i < key.length(); i++) {
+        int index = key[i] - 'a';
+        if (!pCrawl->children[index])
+            pCrawl->children[index] = new TrieNode;
+        pCrawl = pCrawl->children[index];
+    }
+    pCrawl->isEndOfWord = true;
+}
+```
+
+## Search
+
+Searching for a key is similar to insert operation, however we only compare the characters and move down. The search can terminate due to end of string or lack of key in Trie. In the former case, if the isEndofWord field of last node is true, then the key exists in Trie. In the second case, the search terminates without examining all the characters of key, since the key is not present in Trie.
+
+```cpp
+bool search(struct TrieNode *root, string key) {
+    TrieNode *pCrawl = root;
+    for (int i = 0; i < key.length(); i++) {
+        int index = key[i] - 'a';
+        if (!pCrawl->children[index])
+            return false;
+        pCrawl = pCrawl->children[index];
+    }
+    return (pCrawl != NULL && pCrawl->isEndOfWord);
+}
+```
+
+Insert and search costs $\mathcal{O}(\text{key\_length})$. However the memory requirements of Trie high. It is $\mathcal{O}(\text{ALPHABET SIZE} \times \text{key\_length} \times N)$ where $N$ is number of keys in Trie. There are efficient representation of trie nodes (e.g. compressed trie, ternary search tree, etc.) to minimize memory requirements of trie.

docs/data-structures/mo-algorithm.md

@@ -0,0 +1,58 @@
+---
+title: Bipartite Checking
+tags:
+    - Bipartite Checking
+    - Graph
+---
+
+The question is in the title. Is the given graph bipartite? We can use BFS or DFS on graph. Lets first focus on BFS related algorithm. This procedure is very similar to BFS, we have an extra color array and we assign a color to each vertex when we are traversing the graph. Algorithm proof depends on fact that BFS explores the graph level by level. If the graph contains an odd cycle it means that there must be a edge between two vertices that are in same depth (layer, proof can be found on [[1 - Algorithm Design, Kleinberg, Tardos]]()). Let's say the colors are red and black and we traverse the graph with BFS and assign red to odd layers and black to even layers. Then we check the edges to see if there exists an edge that its vertices are same color. If there is a such edge, the graph is not bipartite, else the graph is bipartite.
+
+<figure markdown="span">
+![If two nodes x and y in the same layer are joined by an edge, then the cycle through x, y, and their lowest common ancestor z has odd length, demonstrating that the graph cannot be bipartite.](img/bipartite_check.png)
+<figcaption>If two nodes x and y in the same layer are joined by an edge, then the cycle through x, y, and their lowest common ancestor z has odd length, demonstrating that the graph cannot be bipartite.</figcaption>
+</figure>
+
+```cpp
+typedef vector<int> adjList;
+typedef vector<adjList> graph;
+typedef pair<int,int> ii;
+enum COLOR {RED, GREEN};
+bool bipartite_check(graph &g){
+    int root = 0; // Pick 0 indexed node as root.
+    vector<bool> visited(g.size(),false);
+    vector<int> Color(g.size(),0); 
+    queue<ii> Q( { {root,0}} ); // insert root to queue, it is  first layer_0
+    visited[root] = true;
+    Color[root] = RED;
+    while ( !Q.empty() )
+    {
+        /*top.first is node, top.second its depth i.e layer */
+        auto top = Q.front();
+        Q.pop();
+        for (int u : g[top.first]){
+            if ( !visited[u] ){
+                visited[u] = true;
+                //Mark even layers to red, odd layers to green
+                Color[u] = (top.second+1) % 2 == 0 ?  RED : GREEN; 
+                Q.push({u, top.second+1 });
+            }
+        }
+    }
+    for(int i=0; i < g.size(); ++i){
+        for( auto v: g[i]){
+            if ( Color[i] == Color[v] ) return false;
+        }
+    }
+    return true;
+}
+int main(){
+    graph g(3);
+    g[0].push_back(1);
+    g[1].push_back(2);
+    g[2].push_back(3);
+    cout << (bipartite_check(g) == true ? "YES" : "NO") << endl;
+    return 0;
+}
+```
+
+The complexity of algorithm is is $O(V + E) + O(E) $, BFS and loop over edges. But we can say it  $O(V+E)$ since it is Big-O notation.

docs/data-structures/trie.md

@@ -0,0 +1,127 @@
+---
+title: Bridges and Articulation Points
+tags:
+    - Bridge
+    - Articulation Point
+    - Cut Vertex
+    - Cut Edge
+    - Graph
+---
+
+## DFS Order
+
+**DFS order** is traversing all the nodes of a given graph by fixing the root node in the same way as in the DFS algorithm, but without revisiting a discovered node. An important observation here is that the edges and nodes we use will form a **tree** structure. This is because, for every node (**except the root**), we only arrive from another node, and for the **root** node, we do not arrive from any other node, thus forming a **tree** structure.
+
+```cpp
+void dfs(int node){
+    used[node] = true;
+    for(auto it : g[node])
+        if(!used[it])
+            dfs(it);
+}
+```
+
+### Types of Edges
+
+When traversing a graph using DFS order, several types of edges can be encountered. These edges will be very helpful in understanding some graph algorithms.
+
+**Types of Edges:**
+- **Tree edge:** These are the main edges used while traversing the graph.
+- **Forward edge:** These edges lead to a node that has been visited before and is located in our own subtree.
+- **Back edge:** These edges lead to nodes that have been visited before but where the DFS process is not yet complete.
+- **Cross edge:** These edges lead to nodes that have been visited before and where the DFS process is already complete.
+
+An important observation about these edges is that in an undirected graph, it is impossible to have a cross edge. This is because it is not possible for an edge emerging from a node where the DFS process is complete to remain unvisited.
+
+<figure markdown="span" style="width: 36%">
+![Green-colored edges are tree edges. Edge (1,8) is a forward edge. Edge (6,4) is a back edge. Edge (5,4) is a cross edge.](img/types-of-edges.png)
+<figcaption>Green-colored edges are tree edges. Edge (1,8) is a forward edge. Edge (6,4) is a back edge. Edge (5,4) is a cross edge.</figcaption>
+</figure>
+
+## Bridge
+
+In an **undirected** and **connected** graph, if removing an edge causes the graph to become disconnected, this edge is called a **bridge**.
+
+### Finding Bridges
+
+Although there are several algorithms to find bridges (such as **Chain Decomposition**), we will focus on **Tarjan's Algorithm**, which is among the easiest to implement and the fastest.
+
+When traversing a graph using DFS, if there is a **back edge** coming out of the subtree of the lower endpoint of an edge, then that edge is **not** a bridge. This is because the **back edge** prevents the separation of the subtree and its ancestors when the edge is removed.
+
+This algorithm is based exactly on this principle, keeping track of the minimum depth reached by the **back edge**s within the subtree of each node.
+
+If the minimum depth reached by the **back edge**s in the subtree of the lower endpoint of an edge is greater than or equal to the depth of the upper endpoint, then this edge is a **bridge**. This is because no **back edge** in the subtree of the edge's lower endpoint reaches a node above the current edge. Therefore, if we remove this edge, the subtree and its ancestors become disconnected.
+
+Using Tarjan's Algorithm, we can find all bridges in a graph with a time complexity of $\mathcal{O}(V + E)$, where $V$ represents the number of vertices and $E$ represents the number of edges in the graph.
+
+```cpp
+int dfs(int node, int parent, int depth) {
+    int minDepth = depth;
+    dep[node] = depth;  // dep dizisi her dugumun derinligini tutmaktadir.
+    used[node] = true;
+    for (auto it : g[node]) {
+        if (it == parent)
+            continue;
+        if (used[it]) {
+            minDepth = min(minDepth, dep[it]);
+            // Eger komsu dugum daha once kullanilmis ise
+            // Bu edge back edge veya forward edgedir.
+            continue;
+        }
+        int val = dfs(it, node, depth + 1);
+        // val degeri alt agacindan yukari cikan minimum derinliktir.
+        if (val >= depth + 1)
+            bridges.push_back({node, it});
+        minDepth = min(minDepth, val);
+    }
+    return minDepth;
+}
+```
+
+## Articulation Point
+
+In an undirected graph, if removing a node increases the number of connected components, that node is called an **articulation point** or **cut point**.
+
+<figure markdown="span" style="width: 36%">
+![For example, if we remove node 0, the remaining nodes are split into two groups: 5 and 1, 2, 3, 4. Similarly, if we remove node 1, the nodes are split into 5, 0 and 2, 3, 4. Therefore, nodes 0 and 1 are **articulation points**.](img/cut-point.png)
+<figcaption>For example, if we remove node 0, the remaining nodes are split into two groups: 5 and 1, 2, 3, 4. Similarly, if we remove node 1, the nodes are split into 5, 0 and 2, 3, 4. Therefore, nodes 0 and 1 are **articulation points**.</figcaption>
+</figure>
+
+### Finding Articulation Points
+
+Tarjan's Algorithm for finding articulation points in an undirected graph:
+
+- Traverse the graph using DFS order.
+
+- For each node, calculate the depth of the minimum depth node that can be reached from the current node and its subtree through back edges. This value is called the **low** value of the node.
+
+- If the **low** value of any child of a non-root node is greater than or equal to the depth of the current node, then the current node is an **articulation point**. This is because no **back edge** in the subtree of this node can reach a node above the current node. Therefore, if this node is removed, its subtree will become disconnected from its ancestors.
+
+- If the current node is the root (the starting node of the DFS order) and there are multiple branches during the DFS traversal, then the root itself is an **articulation point**. This is because the root has multiple connected subgraphs.
+
+Using Tarjan's Algorithm, we can find all articulation points in a graph with a time complexity of $\mathcal{O}(V + E)$, where $V$ is the number of vertices and $E$ is the number of edges in the graph.
+
+```cpp
+int dfs(int node, int parent, int depth) {
+    int minDepth = depth, children = 0;
+    dep[node] = depth;  // dep array holds depth of each node.
+    used[node] = true;
+    for (auto it : g[node]) {
+        if (it == parent)
+            continue;
+        if (used[it]) {
+            minDepth = min(minDepth, dep[it]);
+            continue;
+        }
+        int val = dfs(it, node, depth + 1);
+        if (val >= depth and parent != -1)
+            isCutPoint[node] = true;
+        minDepth = min(minDepth, val);
+        children++;
+    }
+    // This if represents the root condition that we mentioned above.
+    if (parent == -1 and children >= 2)
+        isCutPoint[node] = true;
+    return minDepth;
+}
+```