add more solutions

Author: ashishps1

python/add_two_numbers.md

@@ -0,0 +1,41 @@
+# [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers/)
+
+## Approach: Iterative Solution with Carry
+
+### Solution
+python
+```python
+# Time Complexity: O(max(m, n)), where m and n are the lengths of the two lists
+# Space Complexity: O(max(m, n)), for the new linked list
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+        dummy = ListNode(0)  # Dummy node to simplify the process
+        current = dummy  # Pointer to the current node in the result list
+        carry = 0  # Store carry from the addition
+
+        # Traverse both lists
+        while l1 is not None or l2 is not None or carry != 0:
+            sum = carry  # Start with the carry
+
+            # Add values from l1 and l2 if they exist
+            if l1 is not None:
+                sum += l1.val
+                l1 = l1.next
+            if l2 is not None:
+                sum += l2.val
+                l2 = l2.next
+
+            # Calculate new carry and the digit to store
+            carry = sum // 10
+            current.next = ListNode(sum % 10)  # Store the last digit of the sum
+            current = current.next  # Move to the next node
+
+        return dummy.next  # Skip the dummy node
+```
+

python/basic_calculator_2.md

@@ -0,0 +1,41 @@
+# [227. Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii/)
+
+## Approach: Using a Stack for Intermediate Results
+
+### Solution
+python
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+class Solution:
+    def calculate(self, s: str) -> int:
+        stack = []
+        current_number = 0
+        operation = '+'  # Default operation is addition
+
+        for i in range(len(s)):
+            c = s[i]
+
+            # Build the current number
+            if c.isdigit():
+                current_number = current_number * 10 + int(c)
+
+            # Process operators and the last number
+            if not c.isdigit() and c != ' ' or i == len(s) - 1:
+                if operation == '+':
+                    stack.append(current_number)
+                elif operation == '-':
+                    stack.append(-current_number)
+                elif operation == '*':
+                    stack.append(stack.pop() * current_number)
+                elif operation == '/':
+                    stack.append(int(stack.pop() / current_number))  # Cast to int for truncation towards zero
+
+                operation = c  # Update the operation
+                current_number = 0  # Reset the current number
+
+        # Sum up all the values in the stack
+        return sum(stack)
+```
+

python/binary_tree_cameras.md

@@ -0,0 +1,89 @@
+# 968. [Binary Tree Cameras](https://leetcode.com/problems/binary-tree-cameras/)
+
+## Approach 1: Greedy Approach with Recursion
+
+### Solution
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(h) where h is the height of the tree (recursion stack)
+class Solution:
+    def __init__(self):
+        self.cameras = 0
+
+    def minCameraCover(self, root: TreeNode) -> int:
+        # If root returns 0, it means it needs a camera
+        return self.dfs(root) == 0 and self.cameras + 1 or self.cameras
+
+    def dfs(self, node: TreeNode) -> int:
+        if not node:
+            return 1  # This node is covered
+        
+        left = self.dfs(node.left)
+        right = self.dfs(node.right)
+        
+        if left == 0 or right == 0:
+            self.cameras += 1
+            return 2  # Placing a camera at this node
+        
+        return 1 if left == 2 or right == 2 else 0
+        # 2 indicates child has a camera, 1 means this node is covered
+        # 0 indicates this node needs a camera
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+```
+
+## Approach 2: Dynamic Programming with State Tracking
+
+### Solution
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+class Solution:
+    HAS_CAMERA = 0
+    COVERED = 1
+    NEEDS_CAMERA = 2
+
+    def minCameraCover(self, root: TreeNode) -> int:
+        dp = {}
+
+        def dfs(node: TreeNode) -> int:
+            if not node:
+                return self.COVERED
+
+            if node not in dp:
+                state = [None, None, None] 
+
+                left = dfs(node.left)
+                right = dfs(node.right)
+                
+                if left == self.NEEDS_CAMERA or right == self.NEEDS_CAMERA:
+                    state[self.HAS_CAMERA] = dp.get(node, [0, 0, 0])[self.HAS_CAMERA] + 1
+                    dp[node] = state
+                    return self.HAS_CAMERA
+                
+                if left == self.HAS_CAMERA or right == self.HAS_CAMERA:
+                    state[self.COVERED] = dp.get(node, [0, 0, 0])[self.COVERED]
+                    dp[node] = state
+                    return self.COVERED
+                
+                state[self.NEEDS_CAMERA] = dp.get(node, [0, 0, 0])[self.NEEDS_CAMERA]
+                dp[node] = state
+                return self.NEEDS_CAMERA
+            
+            return dp[node][0]
+        
+        return dfs(root) == self.NEEDS_CAMERA and dp[root][self.HAS_CAMERA] + 1 or dp[root][self.HAS_CAMERA]
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+```
+
+Note: The second approach is a detailed version using dynamic programming concepts, but the greedy recursive version is typically more straightforward and efficient due to its optimizations for this specific problem.
+

python/binary_tree_level_order_traversal.md

@@ -0,0 +1,78 @@
+# 102. [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)
+
+## Approach 1: Breadth-First Search (Using Queue)
+
+### Solution
+python
+```python
+# Time Complexity: O(n), where n is the number of nodes in the tree
+# Space Complexity: O(n) for the queue and result storage
+from collections import deque
+from typing import List, Optional
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        result = []
+        if not root:
+            return result # Return empty result if the tree is empty
+
+        queue = deque([root])
+
+        while queue:
+            levelSize = len(queue)
+            currentLevel = []
+
+            for _ in range(levelSize):
+                currentNode = queue.popleft() # Process the current node
+                currentLevel.append(currentNode.val)
+
+                if currentNode.left:
+                    queue.append(currentNode.left) # Add left child to the queue
+                if currentNode.right:
+                    queue.append(currentNode.right) # Add right child to the queue
+
+            result.append(currentLevel) # Add the current level to the result
+
+        return result
+```
+
+## Approach 2: Depth-First Search (Recursive)
+
+### Solution
+python
+```python
+# Time Complexity: O(n), where n is the number of nodes in the tree
+# Space Complexity: O(h), where h is the height of the tree for recursion stack
+from typing import List, Optional
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        result = []
+        self.dfs(root, 0, result)
+        return result
+
+    def dfs(self, node: Optional[TreeNode], level: int, result: List[List[int]]):
+        if not node:
+            return # Base case: if the node is null, return
+
+        if level == len(result):
+            result.append([]) # Create a new level in the result
+
+        result[level].append(node.val) # Add the current node's value to the current level
+
+        self.dfs(node.left, level + 1, result) # Recurse for the left child
+        self.dfs(node.right, level + 1, result) # Recurse for the right child
+```
+

python/cheapest_flights_within_k_stops.md

@@ -0,0 +1,105 @@
+# 787. [Cheapest Flights Within K Stops](https://leetcode.com/problems/cheapest-flights-within-k-stops/)
+
+## Approach 1: DFS with Pruning
+
+### Solution
+```python
+# Time Complexity: O(n^k) in the worst case
+# Space Complexity: O(n)
+from collections import defaultdict
+
+class Solution:
+    def __init__(self):
+        self.result = float('inf')
+
+    def findCheapestPrice(self, n, flights, src, dst, K):
+        # Create adjacency map for graph edges
+        graph = defaultdict(dict)
+        for u, v, price in flights:
+            graph[u][v] = price
+
+        # Perform DFS
+        self.dfs(graph, src, dst, K + 1, 0)
+
+        return -1 if self.result == float('inf') else self.result
+
+    def dfs(self, graph, node, dst, stops, cost):
+        if node == dst:
+            self.result = cost
+            return
+
+        if stops == 0:
+            return  # No more stops available
+
+        if node not in graph:
+            return  # No outgoing flights
+
+        for neighbor, price in graph[node].items():
+            # Pruning: proceed only if this path is cheaper than the best found so far
+            if cost + price > self.result:
+                continue
+
+            self.dfs(graph, neighbor, dst, stops - 1, cost + price)
+```
+
+## Approach 2: Bellman-Ford Algorithm
+
+### Solution
+```python
+# Time Complexity: O(K * E), where E is the number of edges
+# Space Complexity: O(n)
+import sys
+
+class Solution:
+    def findCheapestPrice(self, n, flights, src, dst, K):
+        prices = [sys.maxsize] * n
+        prices[src] = 0
+
+        # Relax the edges up to K+1 times
+        for _ in range(K + 1):
+            temp_prices = prices[:]
+            for u, v, price in flights:
+                if prices[u] == sys.maxsize:
+                    continue
+
+                if prices[u] + price < temp_prices[v]:
+                    temp_prices[v] = prices[u] + price
+            prices = temp_prices
+
+        return -1 if prices[dst] == sys.maxsize else prices[dst]
+```
+
+## Approach 3: Dijkstra's Algorithm with Priority Queue
+
+### Solution
+```python
+# Time Complexity: O(E + VlogV), where E is the number of edges and V is the number of vertices
+# Space Complexity: O(n)
+import heapq
+from collections import defaultdict
+
+class Solution:
+    def findCheapestPrice(self, n, flights, src, dst, K):
+        # Create an adjacency list for the graph
+        graph = defaultdict(list)
+        for u, v, price in flights:
+            graph[u].append((v, price))
+
+        # Priority queue will hold entries of (cost, node, stops remaining)
+        pq = [(0, src, K + 1)]
+
+        while pq:
+            cost, node, stops_remaining = heapq.heappop(pq)
+
+            if node == dst:
+                return cost
+
+            if stops_remaining > 0:
+                if node not in graph:
+                    continue
+                for next_node, price_to_next in graph[node]:
+                    heapq.heappush(pq, (cost + price_to_next, next_node, stops_remaining - 1))
+
+        return -1  # No valid path found
+```
+