BFS 1 Done

Problem1.py

@@ -0,0 +1,37 @@
+# Binary Tree Level Order Traversal
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+# Time complexity -> On since we are iteating over each element and prossesing it's child ones
+# Space complexity -> the length of queue
+# Logic - > for each level found all the child at low level and add in the result lest then process all items of that level and continue
+
+
+from collections import deque
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        result = []
+
+        levelQueue = deque()
+
+        if root!=None:
+            levelQueue.append(root)
+
+        while len(levelQueue) > 0:
+            internalList = []
+            itemsInCurrentLevel = len(levelQueue)
+            for i in range(itemsInCurrentLevel):
+                node = levelQueue.popleft()
+                internalList.append(node.val)
+                if node.left != None:
+                    levelQueue.append(node.left)
+                if node.right != None:
+                    levelQueue.append(node.right)
+            result.append(internalList)
+
+        return result

Problem2.py

@@ -0,0 +1,48 @@
+#Course Schedule
+# Time complexity ->  O(E+V) basically the edges (prerequisites) and the v is courses
+# Space complexity -> O(E+V) basically the edges (prerequisites) and the v is courses
+
+# Logic -> Find indegree which is nothing just an array representation of how many courses course i is dependent on. Then
+# starting one with the 0 indegree courses keep updating the iorder for child courses. If indegree of each course is now
+# 0 means possible else not possible
+from collections import deque
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        indegree = [0] * numCourses
+        dependencyMap = {}
+        coursesTaken = 0
+
+        for course, dependentOn in prerequisites:
+            indegree[course] +=1
+            if dependentOn in dependencyMap:
+                dependencyMap[dependentOn].append(course)
+            else:
+                dependencyMap[dependentOn] = [course]
+
+        # found all the courses with no dependencies
+        coursesThatCanBeTaken = deque()
+
+        for i in range(numCourses):
+            if indegree[i] == 0:
+                coursesTaken+=1
+                coursesThatCanBeTaken.append(i)
+
+        if len(coursesThatCanBeTaken) == 0 :
+            return False
+
+        if coursesTaken == numCourses:
+            return True
+
+        while len(coursesThatCanBeTaken) > 0:
+            course = coursesThatCanBeTaken.popleft()
+            if course in dependencyMap:
+                for dependentCr in  dependencyMap[course]:
+                    indegree[dependentCr] -= 1
+                    if indegree[dependentCr] == 0:
+                        coursesTaken+=1
+                        coursesThatCanBeTaken.append(dependentCr)
+                        if coursesTaken == numCourses:
+                            return True
+
+        return coursesTaken == numCourses