diff --git a/.travis.yml b/.travis.yml index 3b55045ac..55ea2c7dd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -21,6 +21,7 @@ script: digital_image_processing divide_and_conquer dynamic_programming + graphs hashes linear_algebra_python matrix diff --git a/graphs/basic_graphs.py b/graphs/basic_graphs.py index 3b3abeb17..ee63ca995 100644 --- a/graphs/basic_graphs.py +++ b/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 diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py index 82db80546..f49157230 100644 --- a/graphs/bellman_ford.py +++ b/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) diff --git a/graphs/dijkstra_2.py b/graphs/dijkstra_2.py index a6c340e8a..8f39aec41 100644 --- a/graphs/dijkstra_2.py +++ b/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) diff --git a/graphs/floyd_warshall.py b/graphs/graphs_floyd_warshall.py similarity index 100% rename from graphs/floyd_warshall.py rename to graphs/graphs_floyd_warshall.py diff --git a/graphs/minimum_spanning_tree_kruskal.py b/graphs/minimum_spanning_tree_kruskal.py index 81d64f421..975151c90 100644 --- a/graphs/minimum_spanning_tree_kruskal.py +++ b/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) diff --git a/graphs/minimum_spanning_tree_prims.py b/graphs/minimum_spanning_tree_prims.py index 7b1ad0e74..0f21b8f49 100644 --- a/graphs/minimum_spanning_tree_prims.py +++ b/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)) diff --git a/graphs/multi_hueristic_astar.py b/graphs/multi_hueristic_astar.py index 1acd098f3..1c01fe9aa 100644 --- a/graphs/multi_hueristic_astar.py +++ b/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) diff --git a/graphs/scc_kosaraju.py b/graphs/scc_kosaraju.py index 1f13ebaba..0d0375203 100644 --- a/graphs/scc_kosaraju.py +++ b/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())