Migrated Graph-2 bundle

Author: muratbiberoglu

docs/graph/bipartite-checking.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/graph/definitions.md

@@ -32,3 +32,31 @@ tags:
     - an undirected graph is connected and has no cycles. an undirected graph is acyclic, and a simple cycle is formed if any edge is added to the graph.
     - an undirected graph is connected, it will become disconnected if any edge is removed.
     - an undirected graph is connected, and has  (number of nodes - 1) edges.
+
+### Bipartite Graphs
+
+A bipartite graph is a graph whose vertices can be divided into two disjoint and independent sets U and V such that every edge connects a vertex in U to one in V. Vertex sets U and V are usually called the parts of the graph. [[1]](https://en.wikipedia.org/wiki/Bipartite\_graph). The figure is shown in below. It is similar to graph coloring with two colors. Coloring graph with two colors is that every vertex have a corresponding color, and for any edge, it's vertices should be different color. In other words, if we can color neighbours two different colors, we can say that graph is bipartite.
+
+<figure markdown="span">
+![Example bipartite graph, all edges satisfy the coloring constraint](img/bipartite.png)
+<figcaption>Example bipartite graph, all edges satisfy the coloring constraint</figcaption>
+</figure>
+
+We have some observations here.
+- A graph 2- colorable if and only if it is bipartite.
+- A graph does not contain odd-length cycle if and only if it is bipartite.
+- Every tree is a bipartite graph since trees do not contain any cycles.
+
+### Directed Acyclic Graphs
+
+A directed acyclic graph(DAG) is a finite directed graph with no directed cycles. Equivalently, a DAG is a directed graph that has a topological ordering (we cover it in this bundle), a sequence of the vertices such that every edge is directed from earlier to later in the sequence [[2]](https://en.wikipedia.org/wiki/Directed_acyclic_graph). DAGs can be used to encode precedence relations or dependencies in a natural way [[3 - Algorithm Design, Kleinberg, Tardos]](). There are several applications using topological ordering directly such as finding  critical path or automatic differentiation on computational graphs (this is extremely useful for deep learning frameworks [[4]](https://pytorch.org/docs/stable/autograd.html)).
+
+<figure markdown="span">
+![Example Directed Acyclic Graphs](img/dag.png)
+<figcaption>Example Directed Acyclic Graphs</figcaption>
+</figure>
+
+<figure markdown="span" style="width: 64%">
+![Example computational graph also a DAG, partial derivatives are written to edges respect to topological order](img/tree-def.png)
+<figcaption>Example computational graph also a DAG, partial derivatives are written to edges respect to topological order</figcaption>
+</figure>