Travis CI: Add pytest --doctest-modules graphs (#1018)

.travis.yml

@@ -21,6 +21,7 @@ script:
       digital_image_processing
       divide_and_conquer
       dynamic_programming
+      graphs
       hashes
       linear_algebra_python
       matrix

graphs/basic_graphs.py

@@ -10,6 +10,8 @@ try:
 except NameError:
     xrange = range  # Python 3
 
+
+if __name__ == "__main__":
     # Accept No. of Nodes and edges
     n, m = map(int, raw_input().split(" "))
 
@@ -19,31 +21,31 @@ for i in xrange(n):
         g[i + 1] = []
 
     """
---------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------
         Accepting edges of Unweighted Directed Graphs
---------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------
     """
     for _ in xrange(m):
-    x, y = map(int, raw_input().split(" "))
+        x, y = map(int, raw_input().strip().split(" "))
         g[x].append(y)
 
     """
---------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------
         Accepting edges of Unweighted Undirected Graphs
---------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------
     """
     for _ in xrange(m):
-    x, y = map(int, raw_input().split(" "))
+        x, y = map(int, raw_input().strip().split(" "))
         g[x].append(y)
         g[y].append(x)
 
     """
---------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------
         Accepting edges of Weighted Undirected Graphs
---------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------
     """
     for _ in xrange(m):
-    x, y, r = map(int, raw_input().split(" "))
+        x, y, r = map(int, raw_input().strip().split(" "))
         g[x].append([y, r])
         g[y].append([x, r])
 
@@ -168,9 +170,10 @@ def topo(G, ind=None, Q=[1]):
 
 
 def adjm():
-    n, a = raw_input(), []
+    n = raw_input().strip()
+    a = []
     for i in xrange(n):
-        a.append(map(int, raw_input().split()))
+        a.append(map(int, raw_input().strip().split()))
     return a, n
 
 

graphs/bellman_ford.py

@@ -34,9 +34,9 @@ def BellmanFord(graph, V, E, src):
 
 
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
+if __name__ == "__main__":
+    V = int(input("Enter number of vertices: ").strip())
+    E = int(input("Enter number of edges: ").strip())
 
     graph = [dict() for j in range(E)]
 
@@ -45,10 +45,10 @@ for i in range(V):
 
     for i in range(E):
 	    print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
+	    src = int(input("Enter source:").strip())
+	    dst = int(input("Enter destination:").strip())
+	    weight = float(input("Enter weight:").strip())
 	    graph[i] = {"src": src,"dst": dst, "weight": weight}
 
-gsrc = int(input("\nEnter shortest path source:"))
+    gsrc = int(input("\nEnter shortest path source:").strip())
     BellmanFord(graph, V, E, gsrc)

graphs/dijkstra_2.py

@@ -37,9 +37,9 @@ def Dijkstra(graph, V, src):
 
 
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
+if __name__ == "__main__":
+    V = int(input("Enter number of vertices: ").strip())
+    E = int(input("Enter number of edges: ").strip())
 
     graph = [[float('inf') for i in range(V)] for j in range(V)]
 
@@ -48,10 +48,10 @@ for i in range(V):
 
     for i in range(E):
 	    print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
+	    src = int(input("Enter source:").strip())
+	    dst = int(input("Enter destination:").strip())
+	    weight = float(input("Enter weight:").strip())
 	    graph[src][dst] = weight
 
-gsrc = int(input("\nEnter shortest path source:"))
+    gsrc = int(input("\nEnter shortest path source:").strip())
     Dijkstra(graph, V, gsrc)

graphs/minimum_spanning_tree_kruskal.py

@@ -1,18 +1,20 @@
 from __future__ import print_function
-num_nodes, num_edges = list(map(int,input().split()))
+
+if __name__ == "__main__":
+    num_nodes, num_edges = list(map(int, input().strip().split()))
 
     edges = []
 
     for i in range(num_edges):
-	node1, node2, cost = list(map(int,input().split()))
+	    node1, node2, cost = list(map(int, input().strip().split()))
 	    edges.append((i,node1,node2,cost))
 
     edges = sorted(edges, key=lambda edge: edge[3])
 
-parent = [i for i in range(num_nodes)]
+    parent = list(range(num_nodes))
 
     def find_parent(i):
-	if(i != parent[i]):
+	    if i != parent[i]:
 		    parent[i] = find_parent(parent[i])
 	    return parent[i]
 
@@ -22,7 +24,7 @@ minimum_spanning_tree = []
     for edge in edges:
 	    parent_a = find_parent(edge[1])
 	    parent_b = find_parent(edge[2])
-	if(parent_a != parent_b):
+	    if parent_a != parent_b:
 		    minimum_spanning_tree_cost += edge[3]
 		    minimum_spanning_tree.append(edge)
 		    parent[parent_a] = parent_b

graphs/minimum_spanning_tree_prims.py

@@ -100,12 +100,13 @@ def PrimsAlgorithm(l):
                     Nbr_TV[ v[0] ] = vertex
     return TreeEdges
 
+if __name__ == "__main__":
     # < --------- Prims Algorithm --------- >
-n = int(input("Enter number of vertices: "))
-e = int(input("Enter number of edges: "))
+    n = int(input("Enter number of vertices: ").strip())
+    e = int(input("Enter number of edges: ").strip())
     adjlist = defaultdict(list)
     for x in range(e):
-    l = [int(x) for x in input().split()]
+        l = [int(x) for x in input().strip().split()]
         adjlist[l[0]].append([ l[1], l[2] ])
         adjlist[l[1]].append([ l[0], l[2] ])
     print(PrimsAlgorithm(adjlist))

graphs/multi_hueristic_astar.py

@@ -263,4 +263,7 @@ def multi_a_star(start, goal, n_hueristic):
 	print()
 	print("# is an obstacle")
 	print("- is the path taken by algorithm")
+
+
+if __name__ == "__main__":
     multi_a_star(start, goal, n_hueristic)

graphs/scc_kosaraju.py

@@ -1,19 +1,5 @@
 from __future__ import print_function
-# n - no of nodes, m - no of edges
-n, m = list(map(int,input().split()))
 
-g = [[] for i in range(n)] #graph
-r = [[] for i in range(n)] #reversed graph
-# input graph data (edges)
-for i in range(m):
-    u, v = list(map(int,input().split()))
-    g[u].append(v)
-    r[v].append(u)
-
-stack = []
-visit = [False]*n
-scc = []
-component = []
 
 def dfs(u):
     global g, r, scc, component, visit, stack
@@ -43,4 +29,21 @@ def kosaraju():
         scc.append(component)
     return scc
 
+
+if __name__ == "__main__":
+    # n - no of nodes, m - no of edges
+    n, m = list(map(int,input().strip().split()))
+
+    g = [[] for i in range(n)] #graph
+    r = [[] for i in range(n)] #reversed graph
+    # input graph data (edges)
+    for i in range(m):
+        u, v = list(map(int,input().strip().split()))
+        g[u].append(v)
+        r[v].append(u)
+
+    stack = []
+    visit = [False]*n
+    scc = []
+    component = []
     print(kosaraju())