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,42 +10,44 @@ try:
 except NameError:
     xrange = range  # Python 3
 
-# Accept No. of Nodes and edges
-n, m = map(int, raw_input().split(" "))
 
-# Initialising Dictionary of edges
-g = {}
-for i in xrange(n):
-    g[i + 1] = []
+if __name__ == "__main__":
+    # Accept No. of Nodes and edges
+    n, m = map(int, raw_input().split(" "))
 
-"""
---------------------------------------------------------------------------------
-    Accepting edges of Unweighted Directed Graphs
---------------------------------------------------------------------------------
-"""
-for _ in xrange(m):
-    x, y = map(int, raw_input().split(" "))
-    g[x].append(y)
+    # Initialising Dictionary of edges
+    g = {}
+    for i in xrange(n):
+        g[i + 1] = []
 
-"""
---------------------------------------------------------------------------------
-    Accepting edges of Unweighted Undirected Graphs
---------------------------------------------------------------------------------
-"""
-for _ in xrange(m):
-    x, y = map(int, raw_input().split(" "))
-    g[x].append(y)
-    g[y].append(x)
+    """
+    ----------------------------------------------------------------------------
+        Accepting edges of Unweighted Directed Graphs
+    ----------------------------------------------------------------------------
+    """
+    for _ in xrange(m):
+        x, y = map(int, raw_input().strip().split(" "))
+        g[x].append(y)
 
-"""
---------------------------------------------------------------------------------
-    Accepting edges of Weighted Undirected Graphs
---------------------------------------------------------------------------------
-"""
-for _ in xrange(m):
-    x, y, r = map(int, raw_input().split(" "))
-    g[x].append([y, r])
-    g[y].append([x, r])
+    """
+    ----------------------------------------------------------------------------
+        Accepting edges of Unweighted Undirected Graphs
+    ----------------------------------------------------------------------------
+    """
+    for _ in xrange(m):
+        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().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

@@ -12,7 +12,7 @@ def printDist(dist, V):
 def BellmanFord(graph, V, E, src):
 	mdist=[float('inf') for i in range(V)]
 	mdist[src] = 0.0
-	
+
 	for i in range(V-1):
 		for j in range(V):
 			u = graph[j]["src"]
@@ -20,7 +20,7 @@ def BellmanFord(graph, V, E, src):
 			w = graph[j]["weight"]
 
 			if mdist[u] != float('inf') and mdist[u] + w < mdist[v]:
-				mdist[v] = mdist[u] + w 
+				mdist[v] = mdist[u] + w
 	for j in range(V):
 			u = graph[j]["src"]
 			v = graph[j]["dst"]
@@ -29,26 +29,26 @@ def BellmanFord(graph, V, E, src):
 			if mdist[u] != float('inf') and mdist[u] + w < mdist[v]:
 				print("Negative cycle found. Solution not possible.")
 				return
-	
-	printDist(mdist, V)	
 
-			
+	printDist(mdist, V)
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
 
-graph = [dict() for j in range(E)]
 
-for i in range(V):
-	graph[i][i] = 0.0
+if __name__ == "__main__":
+    V = int(input("Enter number of vertices: ").strip())
+    E = int(input("Enter number of edges: ").strip())
 
-for i in range(E):
-	print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
-	graph[i] = {"src": src,"dst": dst, "weight": weight}
-	
-gsrc = int(input("\nEnter shortest path source:"))
-BellmanFord(graph, V, E, gsrc)
+    graph = [dict() for j in range(E)]
+
+    for i in range(V):
+	    graph[i][i] = 0.0
+
+    for i in range(E):
+	    print("\nEdge ",i+1)
+	    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:").strip())
+    BellmanFord(graph, V, E, gsrc)

graphs/dijkstra_2.py

@@ -22,36 +22,36 @@ def Dijkstra(graph, V, src):
 	mdist=[float('inf') for i in range(V)]
 	vset = [False for i in range(V)]
 	mdist[src] = 0.0
-	
+
 	for i in range(V-1):
 		u = minDist(mdist, vset, V)
 		vset[u] = True
-		
+
 		for v in range(V):
 			if (not vset[v]) and graph[u][v]!=float('inf') and mdist[u] + graph[u][v] < mdist[v]:
-				mdist[v] = mdist[u] + graph[u][v] 
+				mdist[v] = mdist[u] + graph[u][v]
 
-	
 
-	printDist(mdist, V)	
 
-			
+	printDist(mdist, V)
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
 
-graph = [[float('inf') for i in range(V)] for j in range(V)]
 
-for i in range(V):
-	graph[i][i] = 0.0
+if __name__ == "__main__":
+    V = int(input("Enter number of vertices: ").strip())
+    E = int(input("Enter number of edges: ").strip())
 
-for i in range(E):
-	print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
-	graph[src][dst] = weight
+    graph = [[float('inf') for i in range(V)] for j in range(V)]
 
-gsrc = int(input("\nEnter shortest path source:"))
-Dijkstra(graph, V, gsrc)
+    for i in range(V):
+	    graph[i][i] = 0.0
+
+    for i in range(E):
+	    print("\nEdge ",i+1)
+	    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:").strip())
+    Dijkstra(graph, V, gsrc)

graphs/minimum_spanning_tree_kruskal.py

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

graphs/minimum_spanning_tree_prims.py

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

@@ -18,7 +18,7 @@ class PriorityQueue:
 			return self.elements[0][0]
 		else:
 			return float('inf')
-	
+
 	def empty(self):
 		return len(self.elements) == 0
 
@@ -48,10 +48,10 @@ class PriorityQueue:
 				(pro, x) = heapq.heappop(self.elements)
 			for (prito, yyy) in temp:
 				heapq.heappush(self.elements, (prito, yyy))
-	
+
 	def top_show(self):
 		return self.elements[0][1]
-	
+
 	def get(self):
 		(priority, item) = heapq.heappop(self.elements)
 		self.set.remove(item)
@@ -65,7 +65,7 @@ def consistent_hueristic(P, goal):
 
 def hueristic_2(P, goal):
 	# integer division by time variable
-	return consistent_hueristic(P, goal) // t 
+	return consistent_hueristic(P, goal) // t
 
 def hueristic_1(P, goal):
 	# manhattan distance
@@ -74,13 +74,13 @@ def hueristic_1(P, goal):
 def key(start, i, goal, g_function):
 	ans = g_function[start] + W1 * hueristics[i](start, goal)
 	return ans
-	
+
 def do_something(back_pointer, goal, start):
 	grid = np.chararray((n, n))
 	for i in range(n):
 		for j in range(n):
 			grid[i][j] = '*'
-	
+
 	for i in range(n):
 		for j in range(n):
 			if (j, (n-1)-i) in blocks:
@@ -94,7 +94,7 @@ def do_something(back_pointer, goal, start):
 		grid[(n-1)-y_c][x_c] = "-"
 		x = back_pointer[x]
 	grid[(n-1)][0] = "-"
-	
+
 
 	for i in xrange(n):
 		for j in range(n):
@@ -112,7 +112,7 @@ def do_something(back_pointer, goal, start):
 	print("PATH TAKEN BY THE ALGORITHM IS:-")
 	x = back_pointer[goal]
 	while x != start:
-		print(x, end=' ') 
+		print(x, end=' ')
 		x = back_pointer[x]
 	print(x)
 	quit()
@@ -153,7 +153,7 @@ def expand_state(s, j, visited, g_function, close_list_anchor, close_list_inad,
 							if key(neighbours, var, goal, g_function) <= W2 * key(neighbours, 0, goal, g_function):
 								# print("why not plssssssssss")
 								open_list[j].put(neighbours, key(neighbours, var, goal, g_function))
-			
+
 
 	# print
 
@@ -212,7 +212,7 @@ def multi_a_star(start, goal, n_hueristic):
 	for i in range(n_hueristic):
 		open_list.append(PriorityQueue())
 		open_list[i].put(start, key(start, i, goal, g_function))
-	
+
 	close_list_anchor = []
 	close_list_inad = []
 	while open_list[0].minkey() < float('inf'):
@@ -263,4 +263,7 @@ def multi_a_star(start, goal, n_hueristic):
 	print()
 	print("# is an obstacle")
 	print("- is the path taken by algorithm")
-multi_a_star(start, goal, n_hueristic)
+
+
+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
 
-print(kosaraju())
+
+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())