generate all paths

Author: unknown

generateallpaths.py

@@ -0,0 +1,45 @@
+# dfs / recursively
+# current index -> matrix[i][j]
+# first check if the present index is valid
+# check if the current index can be explored
+# move right , down , diagonal
+# else backtrack
+
+def findPaths(m,path,i,j):
+    r,c = len(m),len(m[0])
+    # if destination is reached
+    # print
+    if i == r-1 and j == c-1:
+        print(path+[m[i][j]])
+        return
+
+    # explore
+    path.append(m[i][j])
+
+
+    # move down
+    if 0 <= i+1 <= r-1 and 0 <= j <= c-1:
+        findPaths(m,path,i+1,j)
+
+
+    # move right
+    if 0 <= i <= r-1 and 0 <= j+1 <= c-1:
+        findPaths(m,path,i,j+1)
+
+
+    # move diagonal
+    if 0 <= i+1 <= r-1 and 0 <= j+1 <= c-1:
+        findPaths(m,path,i+1,j+1)
+
+    # if none of the above is explorable or invalid index
+    # backtrack
+    path.pop()
+
+mat = []
+n = int(input())
+for i in range(n):
+    row = list(map(int,input().split()))
+    mat.append(row)
+
+path = []
+findPaths(mat,path,0,0)

shortestpath.py

@@ -0,0 +1,30 @@
+import heapq
+from collections import defaultdict
+
+
+def shortestPath(graph,src,dest):
+    h = []
+    # keep a track record of vertices with the cost
+    # heappop will return vertex with least cost
+    # greedy SRC -> MIN - > MIN -> MIN -> DEST
+
+    heapq.heappush(h,(0,src))
+   
+    while len(h)!=0:
+        currcost,currvtx = heapq.heappop(h)
+        if currvtx == dest:
+            print("Path Exisits {} to {} with cost {}".format(src,dest,currcost))
+            break
+        for neigh,neighcost in graph[currvtx]:
+            heapq.heappush(h,(currcost+neighcost,neigh))
+            
+        
+    
+    
+graph = defaultdict(list)
+v,e = map(int,input().split())
+for i in range(e):
+    u,v,w = map(str,input().split())
+    graph[u].append((v,int(w)))
+src,dest = map(str,input().split())
+shortestPath(graph,src,dest)