Added Graph algorithms and some recursion problems

Graph Algorithms/Bellman Ford algorithm.py

@@ -0,0 +1,107 @@
+import sys
+
+
+class Node(object):
+    def __init__(self, name):
+        self.name = name
+        self.visited = False
+        self.adjacencyList = []
+        self.predecessor = None
+        self.minDistance = sys.maxsize
+
+
+class Edge(object):
+    def __init__(self, weight, startVertex, targetVertex):
+        self.weight = weight
+        self.startVertex = startVertex
+        self.targetVertex = targetVertex
+
+
+class Bellman_Ford(object):
+    HAS_CYCLE = False
+
+    def calculate_shortest_path(self, edgeList, vertexList, startVertex):
+        startVertex.minDistance = 0
+
+        for i in range(0, len(vertexList)-1):
+            for edge in edgeList:
+                u = edge.startVertex
+                v = edge.targetVertex
+                tempDist = u.minDistance + edge.weight
+
+                if tempDist < v.minDistance:
+                    v.minDistance = tempDist
+                    v.predecessor = u
+        for edge in edgeList:
+            if self.hasCycle(edge):
+                print("Negative cycle detected......")
+                Bellman_Ford.HAS_CYCLE = True
+                return
+
+    def hasCycle(self, edge):
+        if (edge.startVertex.minDistance + edge.weight) < edge.targetVertex.minDistance:
+            return True
+        else:
+            return False
+
+    def get_shortest_path(self, targetVertex):
+        if Bellman_Ford.HAS_CYCLE is not None:
+            print("The path to the vertex {} is {}".format(targetVertex.name, targetVertex.minDistance))
+            node = targetVertex
+            while node is not None:
+                print(node.name)
+                node = node.predecessor
+        else:
+            print("The graph has a negative cycle")
+
+
+node1 = Node("A")
+node2 = Node("B")
+node3 = Node("C")
+node4 = Node("D")
+node5 = Node("E")
+node6 = Node("F")
+node7 = Node("G")
+node8 = Node("H")
+
+edge1 = Edge(5, node1, node2)
+edge2 = Edge(8, node1, node8)
+edge3 = Edge(9, node1, node5)
+edge4 = Edge(15, node2, node4)
+edge5 = Edge(12, node2, node3)
+edge6 = Edge(4, node2, node8)
+edge7 = Edge(7, node8, node3)
+edge8 = Edge(6, node8, node6)
+edge9 = Edge(5, node5, node8)
+edge10 = Edge(4, node5, node6)
+edge11 = Edge(20, node5, node7)
+edge12 = Edge(1, node6, node3)
+edge13 = Edge(13, node6, node7)
+edge14 = Edge(3, node3, node4)
+edge15 = Edge(11, node3, node7)
+edge16 = Edge(9, node4, node7)
+
+node1.adjacencyList.append(edge1)
+node1.adjacencyList.append(edge2)
+node1.adjacencyList.append(edge3)
+node2.adjacencyList.append(edge4)
+node2.adjacencyList.append(edge5)
+node2.adjacencyList.append(edge6)
+node8.adjacencyList.append(edge7)
+node8.adjacencyList.append(edge8)
+node5.adjacencyList.append(edge9)
+node5.adjacencyList.append(edge10)
+node5.adjacencyList.append(edge11)
+node6.adjacencyList.append(edge12)
+node6.adjacencyList.append(edge13)
+node3.adjacencyList.append(edge14)
+node3.adjacencyList.append(edge15)
+node4.adjacencyList.append(edge16)
+
+
+vertexList = (node1, node2, node3, node4, node5, node6, node7, node8)
+edgeList = (edge1, edge2, edge3, edge4, edge5, edge6, edge7, edge8, edge9, edge10, edge11, edge12, edge13, edge14, edge15, edge16)
+
+algorithm = Bellman_Ford()
+algorithm.calculate_shortest_path(edgeList, vertexList, node1)
+algorithm.get_shortest_path(node7)

Graph Algorithms/Breadth First Search.py

@@ -0,0 +1,50 @@
+class Node(object):
+    def __init__(self, name):
+        # This will store the data of the node
+        self.name = name
+        # This is the neighbours of the node
+        self.adjacencyList = []
+        # We create a boolean to check the node is visited or not
+        self.visited = False
+        # Should ask
+        self.predecessor = None
+
+
+class BreadthFirstSearch(object):
+    def bfs(self, start_node):
+        # We create a queue with the starting node
+        queue = [start_node]
+        # We set that the given node is visited
+        start_node.visited = True
+        # We iterate through the queue until it's not empty
+        while queue:
+            # We get the first item in the queue -> FIFO structure
+            actual_node = queue.pop(0)
+            # We print it out
+            print(actual_node.name)
+            # We iterate through the neighbours and visit them also adding them to the queue
+            for node in actual_node.adjacencyList:
+                if not node.visited:
+                    node.visited = True
+                    queue.append(node)
+
+
+n1 = Node("A")
+n2 = Node("B")
+n3 = Node("C")
+n4 = Node("D")
+n5 = Node("E")
+n6 = Node("F")
+n7 = Node("G")
+n8 = Node("H")
+
+n1.adjacencyList.append(n2)
+n1.adjacencyList.append(n3)
+n2.adjacencyList.append(n4)
+n2.adjacencyList.append(n5)
+n1.adjacencyList.append(n6)
+n3.adjacencyList.append(n7)
+n4.adjacencyList.append(n8)
+
+bfs = BreadthFirstSearch()
+bfs.bfs(n1)

Graph Algorithms/CycleDetection.cpp

@@ -0,0 +1,81 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// 0-> unvisited
+// 1-> processing
+// 2-> exited
+vector<int> visited;
+bool found = false;
+vector<int> ans;
+vector<int> curStack;
+
+void DFS(vector<int> graph[], int node){
+    if (visited[node] != 0) return;
+
+    visited[node] = 1;
+    curStack.push_back(node);
+
+    for (int neighbour: graph[node]){
+        if (visited[neighbour] == 1){
+            // Found a cycle
+            found = true;
+            ans.push_back(neighbour);
+            while (curStack.back() != neighbour){
+                ans.push_back(curStack.back());
+                curStack.pop_back();
+            }
+            ans.push_back(neighbour);
+            reverse(ans.begin(), ans.end());
+            return;
+        }
+
+        else if (visited[neighbour] == 0){
+            DFS(graph, neighbour);
+        }
+        if (found) return;
+    }
+
+    curStack.pop_back();
+    visited[node] = 2; // Done processing
+}
+
+void solve(vector<int> graph[], int n){
+    for (int i=0; i<n; i++){
+        if (!visited[i]){
+            DFS(graph, i);
+            if (found) break;
+        }
+    }
+    if (! found){
+        cout << "NO" << endl;
+    }
+    else{
+        cout << "YES" << endl;
+        cout << ans.size() << endl;
+        for (int ele: ans){
+            cout << ele + 1 << " ";
+        }
+        cout << "\n";
+    }
+}
+
+int main(){
+    int n, m;
+    cin >> n >> m;
+
+    vector<int> graph[n];
+    visited.resize(n+1);
+    fill(visited.begin(), visited.end(), false);
+
+    while (m--){
+        int u, v;
+        cin >> u >> v;
+        u--; v--;
+        graph[u].push_back(v);
+    }
+    solve(graph, n);
+
+
+    return 0;
+}

Graph Algorithms/Depth First Search.py

@@ -0,0 +1,42 @@
+class Node(object):
+    def __init__(self, name):
+        self.name = name
+        self.adjacencyList = []
+        self.visited = False
+        self.predecessor = None
+
+
+class DepthFirstSearch(object):
+    # This is the recursive solution
+    def dfs(self, node):
+        # We set the node to be visited
+        node.visited = True
+        # We print it
+        print(node.name)
+        # Then we iterate through the neighbour list
+        for n in node.adjacencyList:
+            # If it is not visited we call the function recursively
+            if not n.visited:
+                # We don't return so it will iterate fully
+                self.dfs(n)
+
+
+n1 = Node("A")
+n2 = Node("B")
+n3 = Node("C")
+n4 = Node("D")
+n5 = Node("E")
+n6 = Node("F")
+n7 = Node("G")
+n8 = Node("H")
+
+n1.adjacencyList.append(n2)
+n1.adjacencyList.append(n3)
+n2.adjacencyList.append(n4)
+n2.adjacencyList.append(n5)
+n1.adjacencyList.append(n6)
+n3.adjacencyList.append(n7)
+n4.adjacencyList.append(n8)
+
+dfs = DepthFirstSearch()
+dfs.dfs(n1)