Add BFS DFS notes

Added CLIQUED Solution

Signed-off-by: inishchith <inishchith@gmail.com>

Author: inishchith

Algorithms/DFS_BFS.md

@@ -0,0 +1,76 @@
+## Graph traversals
+
+Graph traversal means visiting every vertex and edge exactly once in a well-defined order. While using certain graph algorithms, you must ensure that each vertex of the graph is visited exactly once.
+
+During a traversal, it is important that you track which vertices have been visited. The most common way of tracking vertices is to mark them , most commonly done by mainting a `boolean array` .
+
+|Nodes| A   |      B      |  C | D   |      E      |  F |
+|----------|:-------------:|------:|----------|:-------------:|------:|-----:|
+| Array | 0 | 1 | 1 | 0 | 0 | 0 |
+
+>  `BFS` and `DFS` are the two most commonly used graph traversal approach .
+
+### Breadth First Search (BFS) 
+
+>As the name BFS suggests, you are required to traverse the graph breadthwise .
+
+BFS is a traversing algorithm where you should start traversing from a selected node (source or starting node) and traverse the graph `layerwise` (i.e breadthwise) thus exploring the neighbour nodes (nodes which are directly connected to source node). You must then move towards the next-level neighbour nodes.
+
+1. First move horizontally and visit all the nodes of the
+2. current layer and then Move to the next layer .
+
+In this case , we use `queue` data structure to maintain the order of traversal of nodes so as to traverse breadthwise we add it's `unvisited` neighbours(vertices that are directly connected to it) to the queue and move on to the next node in the current layer (i.e breadth) .
+
+```cpp
+BFS (G, s)                   //Where G is the graph and s is the source node
+      let Q be queue.
+      Q.enqueue( s ) //Inserting s in queue until all its neighbour vertices are marked.
+
+      mark s as visited.
+      while ( Q is not empty)
+           //Removing that vertex from queue,whose neighbour will be visited now
+           v  =  Q.dequeue( )
+
+          //processing all the neighbours of v  
+          for all neighbours w of v in Graph G
+               if w is not visited
+                        Q.enqueue( w )             //Stores w in Q to further visit its neighbour
+                        mark w as visited.
+```
+
+### Depth First Search (DFS) 
+
+> DEPTH first search , as the name suggests ; we explore a particular node untill it's depth and then it's breadthwise neighbours .
+
+The DFS algorithm is a recursive algorithm that uses the idea of backtracking. It involves exhaustive searches of all the nodes by going ahead, if possible, else by backtracking.
+
+Here, the word backtrack means that when you are moving forward and there are no more nodes along the current path, you move backwards on the same path to find nodes to traverse. All the nodes will be visited on the current path till all the unvisited nodes have been traversed after which the next path will be selected.
+
+This recursive nature of DFS can be implemented using stacks. The basic idea is as follows:
+Pick a starting node and push all its adjacent nodes into a stack.
+Pop a node from stack to select the next node to visit and push all its adjacent nodes into a stack.
+Repeat this process until the stack is empty. However, ensure that the nodes that are visited are marked. This will prevent you from visiting the same node more than once. If you do not mark the nodes that are visited and you visit the same node more than once, you may end up in an infinite loop.
+
+```cpp
+DFS-iterative (G, s):                                   //Where G is graph and s is source vertex
+  let S be stack
+  S.push( s )            //Inserting s in stack
+  mark s as visited.
+  while ( S is not empty):
+      //Pop a vertex from stack to visit next
+      v  =  S.top( )
+     S.pop( )
+     //Push all the neighbours of v in stack that are not visited   
+    for all neighbours w of v in Graph G:
+        if w is not visited :
+                 S.push( w )         
+                mark w as visited
+```
+
+[DFS BFS Algorithm](./DFS_BFS.cpp)
+
+<p align="center">
+<img src = "http://www.stoimen.com/blog/wp-content/uploads/2012/09/1.-DFS-vs.-BFS.png">
+</p>
+
+[FOOTNOTES](https://www.hackerearth.com/practice/algorithms/graphs/breadth-first-search/tutorial/)

Problems/CLIQUED.cpp

@@ -0,0 +1,74 @@
+/*
+ Problem Link : https://www.codechef.com/problems/CLIQUED
+ */
+
+#include<iostream>
+#include<vector>
+#include<set>
+#define pi pair< long long int, long long int >
+#define llu long long int
+#define INF 1e18
+using namespace std;
+
+int main()
+{
+	llu t,n,k,x,m,s,i,j,a,b,c,curr;
+	cin>>t;
+	while(t--)
+	{
+		cin>>n>>k>>x>>m>>s;s--;
+		vector <pi> roads[n+1];
+		vector <pi>::iterator it;
+		
+		for(i=0;i<k;i++)
+		{
+			roads[i].push_back(make_pair(x,n));
+			roads[n].push_back(make_pair(x,i));
+		}
+		
+		for(i=0;i<m;i++)
+		{
+			cin>>a>>b>>c;
+			a--;b--;
+			
+			roads[a].push_back(make_pair(2*c,b));
+			roads[b].push_back(make_pair(2*c,a));
+		}
+		
+		llu dist[n+1];
+		bool visited[n+1];
+		for(i=0;i<=n;i++)
+		{
+			dist[i]=INF;
+			visited[i] = false;
+		}
+		dist[s]=0;
+		set <pi> spt;
+		spt.insert(make_pair(0,s));
+		
+		while(!spt.empty())
+		{
+			curr = spt.begin()->second;
+			spt.erase(spt.begin());
+			
+			if(visited[curr] == false)
+			{
+				for(it=roads[curr].begin();it!=roads[curr].end();it++)
+				{
+					if(dist[curr]+it->first < dist[it->second])
+					{
+						spt.erase(make_pair(dist[it->second],it->second));
+						dist[it->second]=dist[curr]+it->first;
+						spt.insert(make_pair(dist[it->second],it->second));
+					}
+				}
+			}
+		}
+		
+		for(i=0;i<n;i++) cout<<dist[i]/2<<" ";
+		cout<<endl;
+	}
+	return 0;
+}
+		
+		

README.md

@@ -22,5 +22,5 @@ We hope it will help you understand graphs better and make it possible for you t
 * [Problems](./Problems)
   * [Discount on crackers](https://www.codechef.com/problems/ACM14KG3) | [Solution](https://github.com/KJSCE-Codecell/Graph-notes/blob/master/Problems/ACM14KG3.cpp)
   * [Skiing](https://www.codechef.com/problems/SKIING) | [Solution](https://github.com/KJSCE-Codecell/Graph-notes/blob/master/Problems/SKIING.cpp)
-  * [fillmtr](https://www.codechef.com/problems/FILLMTR) | [Solution](./Problems/fillmtr.cpp)
-
+  * [Bear and Clique Distances](https://www.codechef.com/problems/CLIQUED) | [Solution](./Problems/CLIQUED.cpp)
+  * [Fill The Matrix](https://www.codechef.com/problems/FILLMTR) | [Solution](./Problems/fillmtr.cpp)